﻿// Copyright (c) ServiceStack, Inc. All Rights Reserved.
// License: https://raw.github.com/ServiceStack/ServiceStack/master/license.txt

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
using ServiceStack.Templates;
using ServiceStack.Text;

#if NETSTANDARD2_0
using Microsoft.Extensions.Primitives;
#endif

namespace ServiceStack
{
    public class Command : JsExpression
    {
        public StringSegment Suffix { get; set; }

        public override int IndexOfMethodEnd(StringSegment commandsString, int pos)
        {
            // finding end of suffix, e.g: 'SUM(*) Total' or 'SUM(*) as Total'
            var endPos = pos;
            while (commandsString.Length > endPos && char.IsWhiteSpace(commandsString.GetChar(endPos)))
                endPos++;

            if (commandsString.Length > endPos && commandsString.IndexOf("as ", endPos) == endPos)
                endPos += "as ".Length;

            while (commandsString.Length > endPos && char.IsWhiteSpace(commandsString.GetChar(endPos)))
                endPos++;

            while (commandsString.Length > endPos &&
                   char.IsLetterOrDigit(commandsString.GetChar(endPos)))
                endPos++;

            this.Suffix = commandsString.Subsegment(pos, endPos - pos).TrimEnd();

            return endPos;
        }

        public override string ToDebugString() => base.ToDebugString() + Suffix;

        public override string ToString()
        {
            var sb = StringBuilderCacheAlt.Allocate();
            foreach (var arg in Args)
            {
                if (sb.Length > 0)
                    sb.Append(',');
                sb.Append(arg);
            }

            return $"{Name}({StringBuilderCacheAlt.ReturnAndFree(sb)}){Suffix}";
        }
    }

    public static class StringUtils
    {
        public static List<Command> ParseCommands(this string commandsString)
        {
            return commandsString.ToStringSegment().ParseExpression<Command>(',');
        }

        /// <summary>
        /// Protect against XSS by cleaning non-standared User Input
        /// </summary>
        public static string SafeInput(this string text)
        {
            return string.IsNullOrEmpty(text)
                ? text
                : SafeInputRegEx.Replace(text, string.Empty);
        }

        static readonly Regex StripHtmlUnicodeRegEx = new Regex(@"&(#)?([xX])?([^ \f\n\r\t\v;]+);", RegexOptions.Compiled);
        static readonly Regex SafeInputRegEx = new Regex(@"[^\w\s\.,@-\\+\\/]", RegexOptions.Compiled);

        public static string HtmlEncode(this string html)
        {
            return System.Net.WebUtility.HtmlEncode(html).Replace("′", "&prime;");
        }

        public static string HtmlDecode(this string html)
        {
            return System.Net.WebUtility.HtmlDecode(html);
        }

        public static string ConvertHtmlCodes(this string html)
        {
            return StripHtmlUnicodeRegEx.Replace(html, ConvertHtmlCodeToCharacter);
        }

        static string ConvertHtmlCodeToCharacter(Match match)
        {
            // http://www.w3.org/TR/html5/syntax.html#character-references
            // match.Groups[0] is the entire match, the sub groups start at index one
            if (!match.Groups[1].Success)
            {
                if (HtmlCharacterCodes.TryGetValue(match.Value, out var convertedValue))
                {
                    return convertedValue;
                }

                return match.Value; // ambiguous ampersand
            }

            var decimalString = match.Groups[3].Value;
            ushort decimalValue;
            if (match.Groups[2].Success)
            {
                var parseWasSuccessful = ushort.TryParse(decimalString, NumberStyles.HexNumber,
                    CultureInfo.InvariantCulture, out decimalValue);
                if (!parseWasSuccessful)
                {
                    return match.Value; // ambiguous ampersand
                }
            }
            else
            {
                var parseWasSuccessful = ushort.TryParse(decimalString, out decimalValue);
                if (!parseWasSuccessful)
                {
                    return match.Value; // ambiguous ampersand
                }
            }

            return Convert.ToString((char) decimalValue, CultureInfo.InvariantCulture);
        }

        public static string ToChar(this int codePoint)
        {
            return Convert.ToString(Convert.ToChar(codePoint), CultureInfo.InvariantCulture);
        }

        // http://www.w3.org/TR/html5/entities.json
        // TODO: conditional compilation for NET45 that uses ReadOnlyDictionary
        public static readonly IDictionary<string, string> HtmlCharacterCodes = new SortedDictionary<string, string>
                                                                                    {
                                                                                        { @"&Aacute;", 193.ToChar() },
                                                                                        { @"&aacute;", 225.ToChar() },
                                                                                        { @"&Abreve;", 258.ToChar() },
                                                                                        { @"&abreve;", 259.ToChar() },
                                                                                        { @"&ac;", 8766.ToChar() },
                                                                                        { @"&acd;", 8767.ToChar() },
                                                                                        { @"&acE;", 8766.ToChar() },
                                                                                        { @"&Acirc;", 194.ToChar() },
                                                                                        { @"&acirc;", 226.ToChar() },
                                                                                        { @"&acute;", 180.ToChar() },
                                                                                        { @"&Acy;", 1040.ToChar() },
                                                                                        { @"&acy;", 1072.ToChar() },
                                                                                        { @"&AElig;", 198.ToChar() },
                                                                                        { @"&aelig;", 230.ToChar() },
                                                                                        { @"&af;", 8289.ToChar() },
                                                                                        { @"&Agrave;", 192.ToChar() },
                                                                                        { @"&agrave;", 224.ToChar() },
                                                                                        { @"&alefsym;", 8501.ToChar() },
                                                                                        { @"&aleph;", 8501.ToChar() },
                                                                                        { @"&Alpha;", 913.ToChar() },
                                                                                        { @"&alpha;", 945.ToChar() },
                                                                                        { @"&Amacr;", 256.ToChar() },
                                                                                        { @"&amacr;", 257.ToChar() },
                                                                                        { @"&amalg;", 10815.ToChar() },
                                                                                        { @"&AMP;", 38.ToChar() },
                                                                                        { @"&amp;", 38.ToChar() },
                                                                                        { @"&And;", 10835.ToChar() },
                                                                                        { @"&and;", 8743.ToChar() },
                                                                                        { @"&andand;", 10837.ToChar() },
                                                                                        { @"&andd;", 10844.ToChar() },
                                                                                        {
                                                                                            // { @"&Afr;", 120068.ToChar() },
                                                                                            @"&andslope;",
                                                                                            10840.ToChar()
                                                                                        },
                                                                                        { @"&andv;", 10842.ToChar() },
                                                                                        { @"&ang;", 8736.ToChar() },
                                                                                        { @"&ange;", 10660.ToChar() },
                                                                                        { @"&angle;", 8736.ToChar() },
                                                                                        { @"&angmsd;", 8737.ToChar() },
                                                                                        {
                                                                                            @"&angmsdaa;",
                                                                                            10664.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdab;",
                                                                                            10665.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdac;",
                                                                                            10666.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdad;",
                                                                                            10667.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdae;",
                                                                                            10668.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdaf;",
                                                                                            10669.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdag;",
                                                                                            10670.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&angmsdah;",
                                                                                            10671.ToChar()
                                                                                        },
                                                                                        { @"&angrt;", 8735.ToChar() },
                                                                                        { @"&angrtvb;", 8894.ToChar() },
                                                                                        {
                                                                                            @"&angrtvbd;",
                                                                                            10653.ToChar()
                                                                                        },
                                                                                        { @"&angsph;", 8738.ToChar() },
                                                                                        { @"&angst;", 197.ToChar() },
                                                                                        { @"&angzarr;", 9084.ToChar() },
                                                                                        { @"&Aogon;", 260.ToChar() },
                                                                                        { @"&aogon;", 261.ToChar() },

                                                                                        // { @"&afr;", 120094.ToChar() },
                                                                                        { @"&ap;", 8776.ToChar() },
                                                                                        { @"&apacir;", 10863.ToChar() },
                                                                                        { @"&apE;", 10864.ToChar() },
                                                                                        { @"&ape;", 8778.ToChar() },
                                                                                        { @"&apid;", 8779.ToChar() },
                                                                                        { @"&apos;", 39.ToChar() },
                                                                                        {
                                                                                            // { @"&Aopf;", 120120.ToChar() },
                                                                                            @"&ApplyFunction;",
                                                                                            8289.ToChar()
                                                                                        },
                                                                                        { @"&approx;", 8776.ToChar() },
                                                                                        {
                                                                                            @"&approxeq;", 8778.ToChar()
                                                                                        },
                                                                                        { @"&Aring;", 197.ToChar() },
                                                                                        { @"&aring;", 229.ToChar() },

                                                                                        // { @"&aopf;", 120146.ToChar() },
                                                                                        { @"&Assign;", 8788.ToChar() },
                                                                                        { @"&ast;", 42.ToChar() },
                                                                                        { @"&asymp;", 8776.ToChar() },
                                                                                        { @"&asympeq;", 8781.ToChar() },
                                                                                        { @"&Atilde;", 195.ToChar() },
                                                                                        { @"&atilde;", 227.ToChar() },
                                                                                        { @"&Auml;", 196.ToChar() },
                                                                                        { @"&auml;", 228.ToChar() },
                                                                                        {
                                                                                            // { @"&Ascr;", 119964.ToChar() },
                                                                                            @"&awconint;", 8755.ToChar()
                                                                                        },
                                                                                        { @"&awint;", 10769.ToChar() },
                                                                                        {
                                                                                            @"&backcong;", 8780.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&backepsilon;",
                                                                                            1014.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&backprime;",
                                                                                            8245.ToChar()
                                                                                        },
                                                                                        { @"&backsim;", 8765.ToChar() },
                                                                                        {
                                                                                            @"&backsimeq;",
                                                                                            8909.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Backslash;",
                                                                                            8726.ToChar()
                                                                                        },
                                                                                        { @"&Barv;", 10983.ToChar() },
                                                                                        { @"&barvee;", 8893.ToChar() },
                                                                                        { @"&Barwed;", 8966.ToChar() },
                                                                                        { @"&barwed;", 8965.ToChar() },
                                                                                        {
                                                                                            @"&barwedge;", 8965.ToChar()
                                                                                        },
                                                                                        { @"&bbrk;", 9141.ToChar() },
                                                                                        {
                                                                                            @"&bbrktbrk;", 9142.ToChar()
                                                                                        },
                                                                                        { @"&bcong;", 8780.ToChar() },
                                                                                        { @"&Bcy;", 1041.ToChar() },
                                                                                        { @"&bcy;", 1073.ToChar() },
                                                                                        { @"&bdquo;", 8222.ToChar() },
                                                                                        { @"&becaus;", 8757.ToChar() },
                                                                                        { @"&Because;", 8757.ToChar() },
                                                                                        { @"&because;", 8757.ToChar() },
                                                                                        {
                                                                                            @"&bemptyv;", 10672.ToChar()
                                                                                        },
                                                                                        { @"&bepsi;", 1014.ToChar() },
                                                                                        { @"&bernou;", 8492.ToChar() },
                                                                                        {
                                                                                            @"&Bernoullis;",
                                                                                            8492.ToChar()
                                                                                        },
                                                                                        { @"&Beta;", 914.ToChar() },
                                                                                        { @"&beta;", 946.ToChar() },
                                                                                        { @"&beth;", 8502.ToChar() },
                                                                                        { @"&between;", 8812.ToChar() },

                                                                                        // { @"&ascr;", 119990.ToChar() },
                                                                                        { @"&bigcap;", 8898.ToChar() },
                                                                                        { @"&bigcirc;", 9711.ToChar() },
                                                                                        { @"&bigcup;", 8899.ToChar() },
                                                                                        {
                                                                                            // { @"&Bfr;", 120069.ToChar() },
                                                                                            @"&bigodot;", 10752.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&bigoplus;",
                                                                                            10753.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&bigotimes;",
                                                                                            10754.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&bigsqcup;",
                                                                                            10758.ToChar()
                                                                                        },
                                                                                        { @"&bigstar;", 9733.ToChar() },
                                                                                        {
                                                                                            @"&bigtriangledown;",
                                                                                            9661.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&bigtriangleup;",
                                                                                            9651.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&biguplus;",
                                                                                            10756.ToChar()
                                                                                        },
                                                                                        { @"&bigvee;", 8897.ToChar() },
                                                                                        {
                                                                                            @"&bigwedge;", 8896.ToChar()
                                                                                        },
                                                                                        { @"&bkarow;", 10509.ToChar() },
                                                                                        {
                                                                                            @"&blacklozenge;",
                                                                                            10731.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&blacksquare;",
                                                                                            9642.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&blacktriangle;",
                                                                                            9652.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&blacktriangledown;",
                                                                                            9662.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&blacktriangleleft;",
                                                                                            9666.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&blacktriangleright;",
                                                                                            9656.ToChar()
                                                                                        },
                                                                                        { @"&blank;", 9251.ToChar() },
                                                                                        { @"&blk12;", 9618.ToChar() },
                                                                                        { @"&blk14;", 9617.ToChar() },
                                                                                        { @"&blk34;", 9619.ToChar() },
                                                                                        { @"&block;", 9608.ToChar() },
                                                                                        { @"&bne;", 61.ToChar() },
                                                                                        { @"&bnequiv;", 8801.ToChar() },
                                                                                        { @"&bNot;", 10989.ToChar() },
                                                                                        { @"&bnot;", 8976.ToChar() },

                                                                                        // { @"&bfr;", 120095.ToChar() },
                                                                                        { @"&bot;", 8869.ToChar() },
                                                                                        { @"&bottom;", 8869.ToChar() },
                                                                                        { @"&bowtie;", 8904.ToChar() },
                                                                                        { @"&boxbox;", 10697.ToChar() },
                                                                                        { @"&boxDL;", 9559.ToChar() },
                                                                                        { @"&boxDl;", 9558.ToChar() },
                                                                                        { @"&boxdL;", 9557.ToChar() },
                                                                                        { @"&boxdl;", 9488.ToChar() },
                                                                                        { @"&boxDR;", 9556.ToChar() },
                                                                                        { @"&boxDr;", 9555.ToChar() },
                                                                                        { @"&boxdR;", 9554.ToChar() },
                                                                                        { @"&boxdr;", 9484.ToChar() },
                                                                                        { @"&boxH;", 9552.ToChar() },
                                                                                        { @"&boxh;", 9472.ToChar() },
                                                                                        { @"&boxHD;", 9574.ToChar() },
                                                                                        { @"&boxHd;", 9572.ToChar() },
                                                                                        { @"&boxhD;", 9573.ToChar() },
                                                                                        { @"&boxhd;", 9516.ToChar() },
                                                                                        { @"&boxHU;", 9577.ToChar() },
                                                                                        { @"&boxHu;", 9575.ToChar() },
                                                                                        { @"&boxhU;", 9576.ToChar() },
                                                                                        { @"&boxhu;", 9524.ToChar() },
                                                                                        {
                                                                                            // { @"&Bopf;", 120121.ToChar() },
                                                                                            @"&boxminus;", 8863.ToChar()
                                                                                        },
                                                                                        { @"&boxplus;", 8862.ToChar() },
                                                                                        {
                                                                                            @"&boxtimes;", 8864.ToChar()
                                                                                        },
                                                                                        { @"&boxUL;", 9565.ToChar() },
                                                                                        { @"&boxUl;", 9564.ToChar() },
                                                                                        { @"&boxuL;", 9563.ToChar() },
                                                                                        { @"&boxul;", 9496.ToChar() },
                                                                                        { @"&boxUR;", 9562.ToChar() },
                                                                                        { @"&boxUr;", 9561.ToChar() },
                                                                                        { @"&boxuR;", 9560.ToChar() },
                                                                                        { @"&boxur;", 9492.ToChar() },
                                                                                        { @"&boxV;", 9553.ToChar() },
                                                                                        { @"&boxv;", 9474.ToChar() },
                                                                                        { @"&boxVH;", 9580.ToChar() },
                                                                                        { @"&boxVh;", 9579.ToChar() },
                                                                                        { @"&boxvH;", 9578.ToChar() },
                                                                                        { @"&boxvh;", 9532.ToChar() },
                                                                                        { @"&boxVL;", 9571.ToChar() },
                                                                                        { @"&boxVl;", 9570.ToChar() },
                                                                                        { @"&boxvL;", 9569.ToChar() },
                                                                                        { @"&boxvl;", 9508.ToChar() },
                                                                                        { @"&boxVR;", 9568.ToChar() },
                                                                                        { @"&boxVr;", 9567.ToChar() },
                                                                                        { @"&boxvR;", 9566.ToChar() },
                                                                                        { @"&boxvr;", 9500.ToChar() },
                                                                                        { @"&bprime;", 8245.ToChar() },
                                                                                        { @"&Breve;", 728.ToChar() },
                                                                                        { @"&breve;", 728.ToChar() },
                                                                                        { @"&brvbar;", 166.ToChar() },
                                                                                        { @"&Bscr;", 8492.ToChar() },
                                                                                        { @"&bsemi;", 8271.ToChar() },
                                                                                        { @"&bsim;", 8765.ToChar() },
                                                                                        { @"&bsime;", 8909.ToChar() },
                                                                                        { @"&bsol;", 92.ToChar() },
                                                                                        { @"&bsolb;", 10693.ToChar() },
                                                                                        {
                                                                                            // { @"&bopf;", 120147.ToChar() },
                                                                                            @"&bsolhsub;",
                                                                                            10184.ToChar()
                                                                                        },
                                                                                        { @"&bull;", 8226.ToChar() },
                                                                                        { @"&bullet;", 8226.ToChar() },
                                                                                        { @"&bump;", 8782.ToChar() },
                                                                                        { @"&bumpE;", 10926.ToChar() },
                                                                                        { @"&bumpe;", 8783.ToChar() },
                                                                                        { @"&Bumpeq;", 8782.ToChar() },
                                                                                        { @"&bumpeq;", 8783.ToChar() },
                                                                                        { @"&Cacute;", 262.ToChar() },
                                                                                        { @"&cacute;", 263.ToChar() },
                                                                                        { @"&Cap;", 8914.ToChar() },
                                                                                        { @"&cap;", 8745.ToChar() },
                                                                                        { @"&capand;", 10820.ToChar() },
                                                                                        {
                                                                                            @"&capbrcup;",
                                                                                            10825.ToChar()
                                                                                        },
                                                                                        { @"&capcap;", 10827.ToChar() },
                                                                                        { @"&capcup;", 10823.ToChar() },
                                                                                        { @"&capdot;", 10816.ToChar() },
                                                                                        {
                                                                                            @"&CapitalDifferentialD;",
                                                                                            8517.ToChar()
                                                                                        },
                                                                                        { @"&caps;", 8745.ToChar() },
                                                                                        { @"&caret;", 8257.ToChar() },
                                                                                        { @"&caron;", 711.ToChar() },
                                                                                        { @"&Cayleys;", 8493.ToChar() },
                                                                                        { @"&ccaps;", 10829.ToChar() },
                                                                                        { @"&Ccaron;", 268.ToChar() },
                                                                                        { @"&ccaron;", 269.ToChar() },
                                                                                        { @"&Ccedil;", 199.ToChar() },
                                                                                        { @"&ccedil;", 231.ToChar() },
                                                                                        { @"&Ccirc;", 264.ToChar() },
                                                                                        { @"&ccirc;", 265.ToChar() },
                                                                                        { @"&Cconint;", 8752.ToChar() },
                                                                                        { @"&ccups;", 10828.ToChar() },
                                                                                        {
                                                                                            @"&ccupssm;", 10832.ToChar()
                                                                                        },
                                                                                        { @"&Cdot;", 266.ToChar() },
                                                                                        { @"&cdot;", 267.ToChar() },
                                                                                        { @"&cedil;", 184.ToChar() },
                                                                                        { @"&Cedilla;", 184.ToChar() },
                                                                                        {
                                                                                            @"&cemptyv;", 10674.ToChar()
                                                                                        },
                                                                                        { @"&cent;", 162.ToChar() },
                                                                                        {
                                                                                            @"&CenterDot;", 183.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&centerdot;", 183.ToChar()
                                                                                        },
                                                                                        { @"&Cfr;", 8493.ToChar() },
                                                                                        { @"&CHcy;", 1063.ToChar() },
                                                                                        { @"&chcy;", 1095.ToChar() },
                                                                                        { @"&check;", 10003.ToChar() },
                                                                                        {
                                                                                            // { @"&bscr;", 119991.ToChar() },
                                                                                            @"&checkmark;",
                                                                                            10003.ToChar()
                                                                                        },
                                                                                        { @"&Chi;", 935.ToChar() },
                                                                                        { @"&chi;", 967.ToChar() },
                                                                                        { @"&cir;", 9675.ToChar() },
                                                                                        { @"&circ;", 710.ToChar() },
                                                                                        { @"&circeq;", 8791.ToChar() },
                                                                                        {
                                                                                            @"&circlearrowleft;",
                                                                                            8634.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&circlearrowright;",
                                                                                            8635.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&circledast;",
                                                                                            8859.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&circledcirc;",
                                                                                            8858.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&circleddash;",
                                                                                            8861.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CircleDot;",
                                                                                            8857.ToChar()
                                                                                        },
                                                                                        { @"&circledR;", 174.ToChar() },
                                                                                        {
                                                                                            @"&circledS;", 9416.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CircleMinus;",
                                                                                            8854.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CirclePlus;",
                                                                                            8853.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CircleTimes;",
                                                                                            8855.ToChar()
                                                                                        },
                                                                                        { @"&cirE;", 10691.ToChar() },
                                                                                        { @"&cire;", 8791.ToChar() },
                                                                                        {
                                                                                            @"&cirfnint;",
                                                                                            10768.ToChar()
                                                                                        },
                                                                                        { @"&cirmid;", 10991.ToChar() },
                                                                                        {
                                                                                            @"&cirscir;", 10690.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ClockwiseContourIntegral;",
                                                                                            8754.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CloseCurlyDoubleQuote;",
                                                                                            8221.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&CloseCurlyQuote;",
                                                                                            8217.ToChar()
                                                                                        },
                                                                                        { @"&clubs;", 9827.ToChar() },
                                                                                        {
                                                                                            @"&clubsuit;", 9827.ToChar()
                                                                                        },
                                                                                        { @"&Colon;", 8759.ToChar() },
                                                                                        { @"&colon;", 58.ToChar() },
                                                                                        { @"&Colone;", 10868.ToChar() },
                                                                                        { @"&colone;", 8788.ToChar() },
                                                                                        { @"&coloneq;", 8788.ToChar() },
                                                                                        { @"&comma;", 44.ToChar() },
                                                                                        { @"&commat;", 64.ToChar() },
                                                                                        { @"&comp;", 8705.ToChar() },
                                                                                        { @"&compfn;", 8728.ToChar() },
                                                                                        {
                                                                                            @"&complement;",
                                                                                            8705.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&complexes;",
                                                                                            8450.ToChar()
                                                                                        },
                                                                                        { @"&cong;", 8773.ToChar() },
                                                                                        {
                                                                                            @"&congdot;", 10861.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Congruent;",
                                                                                            8801.ToChar()
                                                                                        },
                                                                                        { @"&Conint;", 8751.ToChar() },
                                                                                        { @"&conint;", 8750.ToChar() },
                                                                                        {
                                                                                            @"&ContourIntegral;",
                                                                                            8750.ToChar()
                                                                                        },
                                                                                        { @"&Copf;", 8450.ToChar() },
                                                                                        { @"&coprod;", 8720.ToChar() },
                                                                                        {
                                                                                            // { @"&cfr;", 120096.ToChar() },
                                                                                            @"&Coproduct;",
                                                                                            8720.ToChar()
                                                                                        },
                                                                                        { @"&COPY;", 169.ToChar() },
                                                                                        { @"&copy;", 169.ToChar() },
                                                                                        { @"&copysr;", 8471.ToChar() },
                                                                                        {
                                                                                            @"&CounterClockwiseContourIntegral;",
                                                                                            8755.ToChar()
                                                                                        },
                                                                                        { @"&crarr;", 8629.ToChar() },
                                                                                        { @"&Cross;", 10799.ToChar() },
                                                                                        { @"&cross;", 10007.ToChar() },

                                                                                        // { @"&copf;", 120148.ToChar() },
                                                                                        { @"&csub;", 10959.ToChar() },
                                                                                        { @"&csube;", 10961.ToChar() },
                                                                                        { @"&csup;", 10960.ToChar() },
                                                                                        { @"&csupe;", 10962.ToChar() },
                                                                                        { @"&ctdot;", 8943.ToChar() },
                                                                                        {
                                                                                            // { @"&Cscr;", 119966.ToChar() },
                                                                                            @"&cudarrl;", 10552.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&cudarrr;", 10549.ToChar()
                                                                                        },
                                                                                        { @"&cuepr;", 8926.ToChar() },
                                                                                        { @"&cuesc;", 8927.ToChar() },
                                                                                        { @"&cularr;", 8630.ToChar() },
                                                                                        {
                                                                                            @"&cularrp;", 10557.ToChar()
                                                                                        },
                                                                                        { @"&Cup;", 8915.ToChar() },
                                                                                        { @"&cup;", 8746.ToChar() },
                                                                                        {
                                                                                            @"&cupbrcap;",
                                                                                            10824.ToChar()
                                                                                        },
                                                                                        { @"&CupCap;", 8781.ToChar() },
                                                                                        { @"&cupcap;", 10822.ToChar() },
                                                                                        { @"&cupcup;", 10826.ToChar() },
                                                                                        { @"&cupdot;", 8845.ToChar() },
                                                                                        { @"&cupor;", 10821.ToChar() },
                                                                                        { @"&cups;", 8746.ToChar() },
                                                                                        { @"&curarr;", 8631.ToChar() },
                                                                                        {
                                                                                            @"&curarrm;", 10556.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&curlyeqprec;",
                                                                                            8926.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&curlyeqsucc;",
                                                                                            8927.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&curlyvee;", 8910.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&curlywedge;",
                                                                                            8911.ToChar()
                                                                                        },
                                                                                        { @"&curren;", 164.ToChar() },
                                                                                        {
                                                                                            @"&curvearrowleft;",
                                                                                            8630.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&curvearrowright;",
                                                                                            8631.ToChar()
                                                                                        },
                                                                                        { @"&cuvee;", 8910.ToChar() },
                                                                                        { @"&cuwed;", 8911.ToChar() },
                                                                                        {
                                                                                            @"&cwconint;", 8754.ToChar()
                                                                                        },
                                                                                        { @"&cwint;", 8753.ToChar() },
                                                                                        { @"&cylcty;", 9005.ToChar() },
                                                                                        { @"&Dagger;", 8225.ToChar() },
                                                                                        { @"&dagger;", 8224.ToChar() },
                                                                                        { @"&daleth;", 8504.ToChar() },
                                                                                        { @"&Darr;", 8609.ToChar() },
                                                                                        { @"&dArr;", 8659.ToChar() },
                                                                                        { @"&darr;", 8595.ToChar() },
                                                                                        { @"&dash;", 8208.ToChar() },
                                                                                        { @"&Dashv;", 10980.ToChar() },
                                                                                        { @"&dashv;", 8867.ToChar() },
                                                                                        {
                                                                                            @"&dbkarow;", 10511.ToChar()
                                                                                        },
                                                                                        { @"&dblac;", 733.ToChar() },
                                                                                        { @"&Dcaron;", 270.ToChar() },
                                                                                        { @"&dcaron;", 271.ToChar() },
                                                                                        { @"&Dcy;", 1044.ToChar() },
                                                                                        { @"&dcy;", 1076.ToChar() },
                                                                                        { @"&DD;", 8517.ToChar() },
                                                                                        { @"&dd;", 8518.ToChar() },
                                                                                        { @"&ddagger;", 8225.ToChar() },
                                                                                        { @"&ddarr;", 8650.ToChar() },
                                                                                        {
                                                                                            @"&DDotrahd;",
                                                                                            10513.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ddotseq;", 10871.ToChar()
                                                                                        },
                                                                                        { @"&deg;", 176.ToChar() },
                                                                                        { @"&Del;", 8711.ToChar() },
                                                                                        { @"&Delta;", 916.ToChar() },
                                                                                        { @"&delta;", 948.ToChar() },
                                                                                        {
                                                                                            @"&demptyv;", 10673.ToChar()
                                                                                        },
                                                                                        { @"&dfisht;", 10623.ToChar() },

                                                                                        // { @"&cscr;", 119992.ToChar() },
                                                                                        { @"&dHar;", 10597.ToChar() },
                                                                                        { @"&dharl;", 8643.ToChar() },
                                                                                        { @"&dharr;", 8642.ToChar() },
                                                                                        {
                                                                                            // { @"&Dfr;", 120071.ToChar() },
                                                                                            @"&DiacriticalAcute;",
                                                                                            180.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DiacriticalDot;",
                                                                                            729.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DiacriticalDoubleAcute;",
                                                                                            733.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DiacriticalGrave;",
                                                                                            96.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DiacriticalTilde;",
                                                                                            732.ToChar()
                                                                                        },
                                                                                        { @"&diam;", 8900.ToChar() },
                                                                                        { @"&Diamond;", 8900.ToChar() },
                                                                                        { @"&diamond;", 8900.ToChar() },
                                                                                        {
                                                                                            @"&diamondsuit;",
                                                                                            9830.ToChar()
                                                                                        },
                                                                                        { @"&diams;", 9830.ToChar() },
                                                                                        { @"&die;", 168.ToChar() },
                                                                                        {
                                                                                            @"&DifferentialD;",
                                                                                            8518.ToChar()
                                                                                        },
                                                                                        { @"&digamma;", 989.ToChar() },
                                                                                        { @"&disin;", 8946.ToChar() },
                                                                                        { @"&div;", 247.ToChar() },
                                                                                        { @"&divide;", 247.ToChar() },
                                                                                        {
                                                                                            @"&divideontimes;",
                                                                                            8903.ToChar()
                                                                                        },
                                                                                        { @"&divonx;", 8903.ToChar() },
                                                                                        { @"&DJcy;", 1026.ToChar() },
                                                                                        { @"&djcy;", 1106.ToChar() },
                                                                                        { @"&dlcorn;", 8990.ToChar() },
                                                                                        { @"&dlcrop;", 8973.ToChar() },
                                                                                        { @"&dollar;", 36.ToChar() },

                                                                                        // { @"&dfr;", 120097.ToChar() },
                                                                                        { @"&Dot;", 168.ToChar() },
                                                                                        { @"&dot;", 729.ToChar() },
                                                                                        { @"&DotDot;", 8412.ToChar() },
                                                                                        { @"&doteq;", 8784.ToChar() },
                                                                                        {
                                                                                            // { @"&Dopf;", 120123.ToChar() },
                                                                                            @"&doteqdot;", 8785.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DotEqual;", 8784.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&dotminus;", 8760.ToChar()
                                                                                        },
                                                                                        { @"&dotplus;", 8724.ToChar() },
                                                                                        {
                                                                                            @"&dotsquare;",
                                                                                            8865.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&doublebarwedge;",
                                                                                            8966.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleContourIntegral;",
                                                                                            8751.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleDot;", 168.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleDownArrow;",
                                                                                            8659.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLeftArrow;",
                                                                                            8656.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLeftRightArrow;",
                                                                                            8660.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLeftTee;",
                                                                                            10980.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLongLeftArrow;",
                                                                                            10232.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLongLeftRightArrow;",
                                                                                            10234.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleLongRightArrow;",
                                                                                            10233.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleRightArrow;",
                                                                                            8658.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleRightTee;",
                                                                                            8872.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleUpArrow;",
                                                                                            8657.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleUpDownArrow;",
                                                                                            8661.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DoubleVerticalBar;",
                                                                                            8741.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownArrow;",
                                                                                            8595.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Downarrow;",
                                                                                            8659.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&downarrow;",
                                                                                            8595.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownArrowBar;",
                                                                                            10515.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownArrowUpArrow;",
                                                                                            8693.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownBreve;", 785.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&downdownarrows;",
                                                                                            8650.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&downharpoonleft;",
                                                                                            8643.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&downharpoonright;",
                                                                                            8642.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownLeftRightVector;",
                                                                                            10576.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownLeftTeeVector;",
                                                                                            10590.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownLeftVector;",
                                                                                            8637.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownLeftVectorBar;",
                                                                                            10582.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownRightTeeVector;",
                                                                                            10591.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownRightVector;",
                                                                                            8641.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&DownRightVectorBar;",
                                                                                            10583.ToChar()
                                                                                        },
                                                                                        { @"&DownTee;", 8868.ToChar() },
                                                                                        {
                                                                                            @"&DownTeeArrow;",
                                                                                            8615.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&drbkarow;",
                                                                                            10512.ToChar()
                                                                                        },
                                                                                        { @"&drcorn;", 8991.ToChar() },
                                                                                        { @"&drcrop;", 8972.ToChar() },

                                                                                        // { @"&dopf;", 120149.ToChar() },
                                                                                        { @"&DScy;", 1029.ToChar() },
                                                                                        { @"&dscy;", 1109.ToChar() },
                                                                                        { @"&dsol;", 10742.ToChar() },
                                                                                        { @"&Dstrok;", 272.ToChar() },
                                                                                        { @"&dstrok;", 273.ToChar() },
                                                                                        { @"&dtdot;", 8945.ToChar() },
                                                                                        { @"&dtri;", 9663.ToChar() },
                                                                                        { @"&dtrif;", 9662.ToChar() },
                                                                                        { @"&duarr;", 8693.ToChar() },
                                                                                        { @"&duhar;", 10607.ToChar() },
                                                                                        {
                                                                                            // { @"&Dscr;", 119967.ToChar() },
                                                                                            @"&dwangle;", 10662.ToChar()
                                                                                        },
                                                                                        { @"&DZcy;", 1039.ToChar() },
                                                                                        { @"&dzcy;", 1119.ToChar() },
                                                                                        {
                                                                                            @"&dzigrarr;",
                                                                                            10239.ToChar()
                                                                                        },
                                                                                        { @"&Eacute;", 201.ToChar() },
                                                                                        { @"&eacute;", 233.ToChar() },
                                                                                        { @"&easter;", 10862.ToChar() },
                                                                                        { @"&Ecaron;", 282.ToChar() },
                                                                                        { @"&ecaron;", 283.ToChar() },
                                                                                        { @"&ecir;", 8790.ToChar() },
                                                                                        { @"&Ecirc;", 202.ToChar() },
                                                                                        { @"&ecirc;", 234.ToChar() },
                                                                                        { @"&ecolon;", 8789.ToChar() },
                                                                                        { @"&Ecy;", 1069.ToChar() },
                                                                                        { @"&ecy;", 1101.ToChar() },
                                                                                        { @"&eDDot;", 10871.ToChar() },
                                                                                        { @"&Edot;", 278.ToChar() },
                                                                                        { @"&eDot;", 8785.ToChar() },
                                                                                        { @"&edot;", 279.ToChar() },
                                                                                        { @"&ee;", 8519.ToChar() },
                                                                                        { @"&efDot;", 8786.ToChar() },

                                                                                        // { @"&dscr;", 119993.ToChar() },
                                                                                        { @"&eg;", 10906.ToChar() },
                                                                                        { @"&Egrave;", 200.ToChar() },
                                                                                        { @"&egrave;", 232.ToChar() },
                                                                                        { @"&egs;", 10902.ToChar() },
                                                                                        { @"&egsdot;", 10904.ToChar() },
                                                                                        { @"&el;", 10905.ToChar() },
                                                                                        { @"&Element;", 8712.ToChar() },
                                                                                        {
                                                                                            // { @"&Efr;", 120072.ToChar() },
                                                                                            @"&elinters;", 9191.ToChar()
                                                                                        },
                                                                                        { @"&ell;", 8467.ToChar() },
                                                                                        { @"&els;", 10901.ToChar() },
                                                                                        { @"&elsdot;", 10903.ToChar() },
                                                                                        { @"&Emacr;", 274.ToChar() },
                                                                                        { @"&emacr;", 275.ToChar() },
                                                                                        { @"&empty;", 8709.ToChar() },
                                                                                        {
                                                                                            @"&emptyset;", 8709.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&EmptySmallSquare;",
                                                                                            9723.ToChar()
                                                                                        },
                                                                                        { @"&emptyv;", 8709.ToChar() },
                                                                                        {
                                                                                            @"&EmptyVerySmallSquare;",
                                                                                            9643.ToChar()
                                                                                        },
                                                                                        { @"&emsp;", 8195.ToChar() },
                                                                                        { @"&emsp13;", 8196.ToChar() },
                                                                                        { @"&emsp14;", 8197.ToChar() },
                                                                                        { @"&ENG;", 330.ToChar() },
                                                                                        { @"&eng;", 331.ToChar() },
                                                                                        { @"&ensp;", 8194.ToChar() },
                                                                                        { @"&Eogon;", 280.ToChar() },
                                                                                        { @"&eogon;", 281.ToChar() },

                                                                                        // { @"&efr;", 120098.ToChar() },
                                                                                        { @"&epar;", 8917.ToChar() },
                                                                                        { @"&eparsl;", 10723.ToChar() },
                                                                                        { @"&eplus;", 10865.ToChar() },
                                                                                        { @"&epsi;", 949.ToChar() },
                                                                                        { @"&Epsilon;", 917.ToChar() },
                                                                                        { @"&epsilon;", 949.ToChar() },
                                                                                        { @"&epsiv;", 1013.ToChar() },
                                                                                        { @"&eqcirc;", 8790.ToChar() },
                                                                                        { @"&eqcolon;", 8789.ToChar() },
                                                                                        { @"&eqsim;", 8770.ToChar() },
                                                                                        {
                                                                                            // { @"&Eopf;", 120124.ToChar() },
                                                                                            @"&eqslantgtr;",
                                                                                            10902.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&eqslantless;",
                                                                                            10901.ToChar()
                                                                                        },
                                                                                        { @"&Equal;", 10869.ToChar() },
                                                                                        { @"&equals;", 61.ToChar() },
                                                                                        {
                                                                                            @"&EqualTilde;",
                                                                                            8770.ToChar()
                                                                                        },
                                                                                        { @"&equest;", 8799.ToChar() },
                                                                                        {
                                                                                            @"&Equilibrium;",
                                                                                            8652.ToChar()
                                                                                        },
                                                                                        { @"&equiv;", 8801.ToChar() },
                                                                                        {
                                                                                            @"&equivDD;", 10872.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&eqvparsl;",
                                                                                            10725.ToChar()
                                                                                        },
                                                                                        { @"&erarr;", 10609.ToChar() },
                                                                                        { @"&erDot;", 8787.ToChar() },
                                                                                        { @"&Escr;", 8496.ToChar() },
                                                                                        { @"&escr;", 8495.ToChar() },
                                                                                        { @"&esdot;", 8784.ToChar() },
                                                                                        { @"&Esim;", 10867.ToChar() },
                                                                                        { @"&esim;", 8770.ToChar() },
                                                                                        { @"&Eta;", 919.ToChar() },
                                                                                        { @"&eta;", 951.ToChar() },
                                                                                        { @"&ETH;", 208.ToChar() },
                                                                                        { @"&eth;", 240.ToChar() },
                                                                                        { @"&Euml;", 203.ToChar() },
                                                                                        { @"&euml;", 235.ToChar() },
                                                                                        { @"&euro;", 8364.ToChar() },
                                                                                        { @"&excl;", 33.ToChar() },
                                                                                        { @"&exist;", 8707.ToChar() },
                                                                                        { @"&Exists;", 8707.ToChar() },
                                                                                        {
                                                                                            @"&expectation;",
                                                                                            8496.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ExponentialE;",
                                                                                            8519.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&exponentiale;",
                                                                                            8519.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&fallingdotseq;",
                                                                                            8786.ToChar()
                                                                                        },
                                                                                        { @"&Fcy;", 1060.ToChar() },
                                                                                        { @"&fcy;", 1092.ToChar() },
                                                                                        { @"&female;", 9792.ToChar() },
                                                                                        { @"&ffilig;", 64259.ToChar() },
                                                                                        { @"&fflig;", 64256.ToChar() },
                                                                                        { @"&ffllig;", 64260.ToChar() },

                                                                                        // { @"&eopf;", 120150.ToChar() },
                                                                                        { @"&filig;", 64257.ToChar() },
                                                                                        {
                                                                                            // { @"&Ffr;", 120073.ToChar() },
                                                                                            @"&FilledSmallSquare;",
                                                                                            9724.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&FilledVerySmallSquare;",
                                                                                            9642.ToChar()
                                                                                        },
                                                                                        { @"&fjlig;", 102.ToChar() },
                                                                                        { @"&flat;", 9837.ToChar() },
                                                                                        { @"&fllig;", 64258.ToChar() },
                                                                                        { @"&fltns;", 9649.ToChar() },
                                                                                        { @"&fnof;", 402.ToChar() },

                                                                                        // { @"&ffr;", 120099.ToChar() },
                                                                                        { @"&ForAll;", 8704.ToChar() },
                                                                                        { @"&forall;", 8704.ToChar() },
                                                                                        { @"&fork;", 8916.ToChar() },
                                                                                        { @"&forkv;", 10969.ToChar() },
                                                                                        {
                                                                                            // { @"&Fopf;", 120125.ToChar() },
                                                                                            @"&Fouriertrf;",
                                                                                            8497.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&fpartint;",
                                                                                            10765.ToChar()
                                                                                        },
                                                                                        { @"&frac12;", 189.ToChar() },
                                                                                        { @"&frac13;", 8531.ToChar() },
                                                                                        { @"&frac14;", 188.ToChar() },
                                                                                        { @"&frac15;", 8533.ToChar() },
                                                                                        { @"&frac16;", 8537.ToChar() },
                                                                                        { @"&frac18;", 8539.ToChar() },
                                                                                        { @"&frac23;", 8532.ToChar() },
                                                                                        { @"&frac25;", 8534.ToChar() },
                                                                                        { @"&frac34;", 190.ToChar() },
                                                                                        { @"&frac35;", 8535.ToChar() },
                                                                                        { @"&frac38;", 8540.ToChar() },
                                                                                        { @"&frac45;", 8536.ToChar() },
                                                                                        { @"&frac56;", 8538.ToChar() },
                                                                                        { @"&frac58;", 8541.ToChar() },
                                                                                        { @"&frac78;", 8542.ToChar() },
                                                                                        { @"&frasl;", 8260.ToChar() },
                                                                                        { @"&frown;", 8994.ToChar() },
                                                                                        { @"&Fscr;", 8497.ToChar() },
                                                                                        { @"&gacute;", 501.ToChar() },
                                                                                        { @"&Gamma;", 915.ToChar() },
                                                                                        { @"&gamma;", 947.ToChar() },
                                                                                        { @"&Gammad;", 988.ToChar() },
                                                                                        { @"&gammad;", 989.ToChar() },
                                                                                        { @"&gap;", 10886.ToChar() },
                                                                                        { @"&Gbreve;", 286.ToChar() },
                                                                                        { @"&gbreve;", 287.ToChar() },
                                                                                        { @"&Gcedil;", 290.ToChar() },
                                                                                        { @"&Gcirc;", 284.ToChar() },
                                                                                        { @"&gcirc;", 285.ToChar() },
                                                                                        { @"&Gcy;", 1043.ToChar() },
                                                                                        { @"&gcy;", 1075.ToChar() },
                                                                                        { @"&Gdot;", 288.ToChar() },
                                                                                        { @"&gdot;", 289.ToChar() },
                                                                                        { @"&gE;", 8807.ToChar() },
                                                                                        { @"&ge;", 8805.ToChar() },
                                                                                        { @"&gEl;", 10892.ToChar() },
                                                                                        { @"&gel;", 8923.ToChar() },
                                                                                        { @"&geq;", 8805.ToChar() },
                                                                                        { @"&geqq;", 8807.ToChar() },
                                                                                        {
                                                                                            // { @"&fopf;", 120151.ToChar() },
                                                                                            @"&geqslant;",
                                                                                            10878.ToChar()
                                                                                        },
                                                                                        { @"&ges;", 10878.ToChar() },
                                                                                        { @"&gescc;", 10921.ToChar() },
                                                                                        { @"&gesdot;", 10880.ToChar() },
                                                                                        {
                                                                                            @"&gesdoto;", 10882.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&gesdotol;",
                                                                                            10884.ToChar()
                                                                                        },
                                                                                        { @"&gesl;", 8923.ToChar() },
                                                                                        { @"&gesles;", 10900.ToChar() },

                                                                                        // { @"&fscr;", 119995.ToChar() },
                                                                                        { @"&Gg;", 8921.ToChar() },
                                                                                        { @"&gg;", 8811.ToChar() },
                                                                                        { @"&ggg;", 8921.ToChar() },
                                                                                        { @"&gimel;", 8503.ToChar() },
                                                                                        { @"&GJcy;", 1027.ToChar() },
                                                                                        { @"&gjcy;", 1107.ToChar() },
                                                                                        { @"&gl;", 8823.ToChar() },
                                                                                        { @"&gla;", 10917.ToChar() },
                                                                                        { @"&glE;", 10898.ToChar() },
                                                                                        { @"&glj;", 10916.ToChar() },
                                                                                        { @"&gnap;", 10890.ToChar() },
                                                                                        {
                                                                                            // { @"&Gfr;", 120074.ToChar() },
                                                                                            @"&gnapprox;",
                                                                                            10890.ToChar()
                                                                                        },
                                                                                        { @"&gnE;", 8809.ToChar() },
                                                                                        { @"&gne;", 10888.ToChar() },
                                                                                        { @"&gneq;", 10888.ToChar() },
                                                                                        { @"&gneqq;", 8809.ToChar() },
                                                                                        { @"&gnsim;", 8935.ToChar() },

                                                                                        // { @"&gfr;", 120100.ToChar() },
                                                                                        { @"&grave;", 96.ToChar() },
                                                                                        {
                                                                                            // { @"&Gopf;", 120126.ToChar() },
                                                                                            @"&GreaterEqual;",
                                                                                            8805.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterEqualLess;",
                                                                                            8923.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterFullEqual;",
                                                                                            8807.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterGreater;",
                                                                                            10914.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterLess;",
                                                                                            8823.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterSlantEqual;",
                                                                                            10878.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&GreaterTilde;",
                                                                                            8819.ToChar()
                                                                                        },
                                                                                        { @"&gscr;", 8458.ToChar() },
                                                                                        { @"&gsim;", 8819.ToChar() },
                                                                                        { @"&gsime;", 10894.ToChar() },
                                                                                        { @"&gsiml;", 10896.ToChar() },
                                                                                        { @"&GT;", 62.ToChar() },
                                                                                        { @"&Gt;", 8811.ToChar() },
                                                                                        { @"&gt;", 62.ToChar() },
                                                                                        { @"&gtcc;", 10919.ToChar() },
                                                                                        { @"&gtcir;", 10874.ToChar() },
                                                                                        { @"&gtdot;", 8919.ToChar() },
                                                                                        { @"&gtlPar;", 10645.ToChar() },
                                                                                        {
                                                                                            // { @"&gopf;", 120152.ToChar() },
                                                                                            @"&gtquest;", 10876.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&gtrapprox;",
                                                                                            10886.ToChar()
                                                                                        },
                                                                                        { @"&gtrarr;", 10616.ToChar() },
                                                                                        { @"&gtrdot;", 8919.ToChar() },
                                                                                        {
                                                                                            @"&gtreqless;",
                                                                                            8923.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&gtreqqless;",
                                                                                            10892.ToChar()
                                                                                        },
                                                                                        { @"&gtrless;", 8823.ToChar() },
                                                                                        { @"&gtrsim;", 8819.ToChar() },
                                                                                        {
                                                                                            @"&gvertneqq;",
                                                                                            8809.ToChar()
                                                                                        },
                                                                                        { @"&gvnE;", 8809.ToChar() },
                                                                                        { @"&Hacek;", 711.ToChar() },
                                                                                        { @"&hairsp;", 8202.ToChar() },
                                                                                        { @"&half;", 189.ToChar() },
                                                                                        { @"&hamilt;", 8459.ToChar() },
                                                                                        { @"&HARDcy;", 1066.ToChar() },
                                                                                        { @"&hardcy;", 1098.ToChar() },
                                                                                        { @"&hArr;", 8660.ToChar() },
                                                                                        { @"&harr;", 8596.ToChar() },
                                                                                        {
                                                                                            @"&harrcir;", 10568.ToChar()
                                                                                        },
                                                                                        { @"&harrw;", 8621.ToChar() },
                                                                                        { @"&Hat;", 94.ToChar() },
                                                                                        { @"&hbar;", 8463.ToChar() },
                                                                                        { @"&Hcirc;", 292.ToChar() },
                                                                                        { @"&hcirc;", 293.ToChar() },
                                                                                        { @"&hearts;", 9829.ToChar() },
                                                                                        {
                                                                                            @"&heartsuit;",
                                                                                            9829.ToChar()
                                                                                        },
                                                                                        { @"&hellip;", 8230.ToChar() },
                                                                                        { @"&hercon;", 8889.ToChar() },
                                                                                        { @"&Hfr;", 8460.ToChar() },
                                                                                        {
                                                                                            // { @"&Gscr;", 119970.ToChar() },
                                                                                            @"&HilbertSpace;",
                                                                                            8459.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&hksearow;",
                                                                                            10533.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&hkswarow;",
                                                                                            10534.ToChar()
                                                                                        },
                                                                                        { @"&hoarr;", 8703.ToChar() },
                                                                                        { @"&homtht;", 8763.ToChar() },
                                                                                        {
                                                                                            @"&hookleftarrow;",
                                                                                            8617.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&hookrightarrow;",
                                                                                            8618.ToChar()
                                                                                        },
                                                                                        { @"&Hopf;", 8461.ToChar() },
                                                                                        { @"&horbar;", 8213.ToChar() },
                                                                                        {
                                                                                            // { @"&hfr;", 120101.ToChar() },
                                                                                            @"&HorizontalLine;",
                                                                                            9472.ToChar()
                                                                                        },
                                                                                        { @"&Hscr;", 8459.ToChar() },
                                                                                        { @"&hslash;", 8463.ToChar() },
                                                                                        { @"&Hstrok;", 294.ToChar() },
                                                                                        { @"&hstrok;", 295.ToChar() },
                                                                                        {
                                                                                            // { @"&hopf;", 120153.ToChar() },
                                                                                            @"&HumpDownHump;",
                                                                                            8782.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&HumpEqual;",
                                                                                            8783.ToChar()
                                                                                        },
                                                                                        { @"&hybull;", 8259.ToChar() },
                                                                                        { @"&hyphen;", 8208.ToChar() },
                                                                                        { @"&Iacute;", 205.ToChar() },
                                                                                        { @"&iacute;", 237.ToChar() },
                                                                                        { @"&ic;", 8291.ToChar() },
                                                                                        { @"&Icirc;", 206.ToChar() },
                                                                                        { @"&icirc;", 238.ToChar() },
                                                                                        { @"&Icy;", 1048.ToChar() },
                                                                                        { @"&icy;", 1080.ToChar() },
                                                                                        { @"&Idot;", 304.ToChar() },
                                                                                        { @"&IEcy;", 1045.ToChar() },
                                                                                        { @"&iecy;", 1077.ToChar() },
                                                                                        { @"&iexcl;", 161.ToChar() },
                                                                                        { @"&iff;", 8660.ToChar() },
                                                                                        { @"&Ifr;", 8465.ToChar() },
                                                                                        { @"&Igrave;", 204.ToChar() },
                                                                                        { @"&igrave;", 236.ToChar() },
                                                                                        { @"&ii;", 8520.ToChar() },
                                                                                        { @"&iiiint;", 10764.ToChar() },
                                                                                        { @"&iiint;", 8749.ToChar() },
                                                                                        { @"&iinfin;", 10716.ToChar() },
                                                                                        { @"&iiota;", 8489.ToChar() },
                                                                                        { @"&IJlig;", 306.ToChar() },
                                                                                        { @"&ijlig;", 307.ToChar() },
                                                                                        { @"&Im;", 8465.ToChar() },
                                                                                        { @"&Imacr;", 298.ToChar() },
                                                                                        { @"&imacr;", 299.ToChar() },
                                                                                        { @"&image;", 8465.ToChar() },
                                                                                        {
                                                                                            // { @"&hscr;", 119997.ToChar() },
                                                                                            @"&ImaginaryI;",
                                                                                            8520.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&imagline;", 8464.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&imagpart;", 8465.ToChar()
                                                                                        },
                                                                                        { @"&imath;", 305.ToChar() },
                                                                                        { @"&imof;", 8887.ToChar() },
                                                                                        { @"&imped;", 437.ToChar() },
                                                                                        { @"&Implies;", 8658.ToChar() },
                                                                                        { @"&in;", 8712.ToChar() },
                                                                                        { @"&incare;", 8453.ToChar() },
                                                                                        { @"&infin;", 8734.ToChar() },
                                                                                        {
                                                                                            @"&infintie;",
                                                                                            10717.ToChar()
                                                                                        },
                                                                                        { @"&inodot;", 305.ToChar() },
                                                                                        { @"&Int;", 8748.ToChar() },
                                                                                        { @"&int;", 8747.ToChar() },
                                                                                        { @"&intcal;", 8890.ToChar() },
                                                                                        {
                                                                                            @"&integers;", 8484.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Integral;", 8747.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&intercal;", 8890.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Intersection;",
                                                                                            8898.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&intlarhk;",
                                                                                            10775.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&intprod;", 10812.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&InvisibleComma;",
                                                                                            8291.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&InvisibleTimes;",
                                                                                            8290.ToChar()
                                                                                        },
                                                                                        { @"&IOcy;", 1025.ToChar() },
                                                                                        { @"&iocy;", 1105.ToChar() },
                                                                                        { @"&Iogon;", 302.ToChar() },
                                                                                        { @"&iogon;", 303.ToChar() },

                                                                                        // { @"&ifr;", 120102.ToChar() },
                                                                                        { @"&Iota;", 921.ToChar() },
                                                                                        { @"&iota;", 953.ToChar() },
                                                                                        { @"&iprod;", 10812.ToChar() },
                                                                                        { @"&iquest;", 191.ToChar() },
                                                                                        { @"&Iscr;", 8464.ToChar() },

                                                                                        // { @"&Iopf;", 120128.ToChar() },
                                                                                        { @"&isin;", 8712.ToChar() },
                                                                                        { @"&isindot;", 8949.ToChar() },
                                                                                        { @"&isinE;", 8953.ToChar() },
                                                                                        { @"&isins;", 8948.ToChar() },
                                                                                        { @"&isinsv;", 8947.ToChar() },
                                                                                        { @"&isinv;", 8712.ToChar() },
                                                                                        { @"&it;", 8290.ToChar() },
                                                                                        { @"&Itilde;", 296.ToChar() },
                                                                                        { @"&itilde;", 297.ToChar() },
                                                                                        { @"&Iukcy;", 1030.ToChar() },
                                                                                        { @"&iukcy;", 1110.ToChar() },
                                                                                        { @"&Iuml;", 207.ToChar() },
                                                                                        { @"&iuml;", 239.ToChar() },
                                                                                        { @"&Jcirc;", 308.ToChar() },
                                                                                        { @"&jcirc;", 309.ToChar() },
                                                                                        { @"&Jcy;", 1049.ToChar() },
                                                                                        { @"&jcy;", 1081.ToChar() },

                                                                                        // { @"&iopf;", 120154.ToChar() },

                                                                                        // { @"&iscr;", 119998.ToChar() },
                                                                                        { @"&jmath;", 567.ToChar() },

                                                                                        // { @"&Jfr;", 120077.ToChar() },

                                                                                        // { @"&jfr;", 120103.ToChar() },
                                                                                        // { @"&Jopf;", 120129.ToChar() },
                                                                                        // { @"&jopf;", 120155.ToChar() },
                                                                                        { @"&Jsercy;", 1032.ToChar() },
                                                                                        { @"&jsercy;", 1112.ToChar() },
                                                                                        { @"&Jukcy;", 1028.ToChar() },
                                                                                        { @"&jukcy;", 1108.ToChar() },
                                                                                        { @"&Kappa;", 922.ToChar() },
                                                                                        { @"&kappa;", 954.ToChar() },
                                                                                        { @"&kappav;", 1008.ToChar() },
                                                                                        { @"&Kcedil;", 310.ToChar() },
                                                                                        { @"&kcedil;", 311.ToChar() },
                                                                                        { @"&Kcy;", 1050.ToChar() },
                                                                                        { @"&kcy;", 1082.ToChar() },

                                                                                        // { @"&Jscr;", 119973.ToChar() },

                                                                                        // { @"&jscr;", 119999.ToChar() },
                                                                                        { @"&kgreen;", 312.ToChar() },
                                                                                        { @"&KHcy;", 1061.ToChar() },
                                                                                        { @"&khcy;", 1093.ToChar() },
                                                                                        { @"&KJcy;", 1036.ToChar() },
                                                                                        { @"&kjcy;", 1116.ToChar() },

                                                                                        // { @"&Kfr;", 120078.ToChar() },

                                                                                        // { @"&kfr;", 120104.ToChar() },
                                                                                        // { @"&Kopf;", 120130.ToChar() },
                                                                                        // { @"&kopf;", 120156.ToChar() },
                                                                                        { @"&lAarr;", 8666.ToChar() },
                                                                                        { @"&Lacute;", 313.ToChar() },
                                                                                        { @"&lacute;", 314.ToChar() },
                                                                                        {
                                                                                            // { @"&Kscr;", 119974.ToChar() },
                                                                                            @"&laemptyv;",
                                                                                            10676.ToChar()
                                                                                        },
                                                                                        { @"&lagran;", 8466.ToChar() },
                                                                                        { @"&Lambda;", 923.ToChar() },
                                                                                        { @"&lambda;", 955.ToChar() },
                                                                                        { @"&Lang;", 10218.ToChar() },
                                                                                        { @"&lang;", 10216.ToChar() },
                                                                                        { @"&langd;", 10641.ToChar() },
                                                                                        { @"&langle;", 10216.ToChar() },
                                                                                        { @"&lap;", 10885.ToChar() },
                                                                                        {
                                                                                            @"&Laplacetrf;",
                                                                                            8466.ToChar()
                                                                                        },
                                                                                        { @"&laquo;", 171.ToChar() },
                                                                                        { @"&Larr;", 8606.ToChar() },
                                                                                        { @"&lArr;", 8656.ToChar() },
                                                                                        { @"&larr;", 8592.ToChar() },
                                                                                        { @"&larrb;", 8676.ToChar() },
                                                                                        {
                                                                                            @"&larrbfs;", 10527.ToChar()
                                                                                        },
                                                                                        { @"&larrfs;", 10525.ToChar() },
                                                                                        { @"&larrhk;", 8617.ToChar() },
                                                                                        { @"&larrlp;", 8619.ToChar() },
                                                                                        { @"&larrpl;", 10553.ToChar() },
                                                                                        {
                                                                                            @"&larrsim;", 10611.ToChar()
                                                                                        },
                                                                                        { @"&larrtl;", 8610.ToChar() },
                                                                                        { @"&lat;", 10923.ToChar() },
                                                                                        { @"&lAtail;", 10523.ToChar() },
                                                                                        { @"&latail;", 10521.ToChar() },
                                                                                        { @"&late;", 10925.ToChar() },
                                                                                        { @"&lates;", 10925.ToChar() },
                                                                                        { @"&lBarr;", 10510.ToChar() },
                                                                                        { @"&lbarr;", 10508.ToChar() },
                                                                                        { @"&lbbrk;", 10098.ToChar() },
                                                                                        { @"&lbrace;", 123.ToChar() },
                                                                                        { @"&lbrack;", 91.ToChar() },
                                                                                        { @"&lbrke;", 10635.ToChar() },
                                                                                        {
                                                                                            @"&lbrksld;", 10639.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&lbrkslu;", 10637.ToChar()
                                                                                        },
                                                                                        { @"&Lcaron;", 317.ToChar() },
                                                                                        { @"&lcaron;", 318.ToChar() },
                                                                                        { @"&Lcedil;", 315.ToChar() },
                                                                                        { @"&lcedil;", 316.ToChar() },
                                                                                        { @"&lceil;", 8968.ToChar() },
                                                                                        { @"&lcub;", 123.ToChar() },
                                                                                        { @"&Lcy;", 1051.ToChar() },
                                                                                        { @"&lcy;", 1083.ToChar() },
                                                                                        { @"&ldca;", 10550.ToChar() },
                                                                                        { @"&ldquo;", 8220.ToChar() },
                                                                                        { @"&ldquor;", 8222.ToChar() },
                                                                                        {
                                                                                            @"&ldrdhar;", 10599.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ldrushar;",
                                                                                            10571.ToChar()
                                                                                        },
                                                                                        { @"&ldsh;", 8626.ToChar() },
                                                                                        { @"&lE;", 8806.ToChar() },
                                                                                        { @"&le;", 8804.ToChar() },
                                                                                        {
                                                                                            @"&LeftAngleBracket;",
                                                                                            10216.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftArrow;",
                                                                                            8592.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Leftarrow;",
                                                                                            8656.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftarrow;",
                                                                                            8592.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftArrowBar;",
                                                                                            8676.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftArrowRightArrow;",
                                                                                            8646.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftarrowtail;",
                                                                                            8610.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftCeiling;",
                                                                                            8968.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftDoubleBracket;",
                                                                                            10214.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftDownTeeVector;",
                                                                                            10593.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftDownVector;",
                                                                                            8643.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftDownVectorBar;",
                                                                                            10585.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftFloor;",
                                                                                            8970.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftharpoondown;",
                                                                                            8637.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftharpoonup;",
                                                                                            8636.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftleftarrows;",
                                                                                            8647.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftRightArrow;",
                                                                                            8596.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Leftrightarrow;",
                                                                                            8660.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftrightarrow;",
                                                                                            8596.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftrightarrows;",
                                                                                            8646.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftrightharpoons;",
                                                                                            8651.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftrightsquigarrow;",
                                                                                            8621.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftRightVector;",
                                                                                            10574.ToChar()
                                                                                        },
                                                                                        { @"&LeftTee;", 8867.ToChar() },
                                                                                        {
                                                                                            @"&LeftTeeArrow;",
                                                                                            8612.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftTeeVector;",
                                                                                            10586.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&leftthreetimes;",
                                                                                            8907.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftTriangle;",
                                                                                            8882.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftTriangleBar;",
                                                                                            10703.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftTriangleEqual;",
                                                                                            8884.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftUpDownVector;",
                                                                                            10577.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftUpTeeVector;",
                                                                                            10592.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftUpVector;",
                                                                                            8639.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftUpVectorBar;",
                                                                                            10584.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftVector;",
                                                                                            8636.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LeftVectorBar;",
                                                                                            10578.ToChar()
                                                                                        },
                                                                                        { @"&lEg;", 10891.ToChar() },
                                                                                        { @"&leg;", 8922.ToChar() },
                                                                                        { @"&leq;", 8804.ToChar() },
                                                                                        { @"&leqq;", 8806.ToChar() },
                                                                                        {
                                                                                            @"&leqslant;",
                                                                                            10877.ToChar()
                                                                                        },
                                                                                        { @"&les;", 10877.ToChar() },
                                                                                        { @"&lescc;", 10920.ToChar() },
                                                                                        { @"&lesdot;", 10879.ToChar() },
                                                                                        {
                                                                                            @"&lesdoto;", 10881.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&lesdotor;",
                                                                                            10883.ToChar()
                                                                                        },
                                                                                        { @"&lesg;", 8922.ToChar() },
                                                                                        { @"&lesges;", 10899.ToChar() },
                                                                                        {
                                                                                            @"&lessapprox;",
                                                                                            10885.ToChar()
                                                                                        },
                                                                                        { @"&lessdot;", 8918.ToChar() },
                                                                                        {
                                                                                            @"&lesseqgtr;",
                                                                                            8922.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&lesseqqgtr;",
                                                                                            10891.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LessEqualGreater;",
                                                                                            8922.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LessFullEqual;",
                                                                                            8806.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LessGreater;",
                                                                                            8822.ToChar()
                                                                                        },
                                                                                        { @"&lessgtr;", 8822.ToChar() },
                                                                                        {
                                                                                            @"&LessLess;",
                                                                                            10913.ToChar()
                                                                                        },
                                                                                        { @"&lesssim;", 8818.ToChar() },
                                                                                        {
                                                                                            @"&LessSlantEqual;",
                                                                                            10877.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LessTilde;",
                                                                                            8818.ToChar()
                                                                                        },
                                                                                        { @"&lfisht;", 10620.ToChar() },
                                                                                        { @"&lfloor;", 8970.ToChar() },

                                                                                        // { @"&kscr;", 120000.ToChar() },
                                                                                        { @"&lg;", 8822.ToChar() },
                                                                                        { @"&lgE;", 10897.ToChar() },
                                                                                        { @"&lHar;", 10594.ToChar() },
                                                                                        { @"&lhard;", 8637.ToChar() },
                                                                                        { @"&lharu;", 8636.ToChar() },
                                                                                        { @"&lharul;", 10602.ToChar() },
                                                                                        { @"&lhblk;", 9604.ToChar() },
                                                                                        { @"&LJcy;", 1033.ToChar() },
                                                                                        { @"&ljcy;", 1113.ToChar() },
                                                                                        { @"&Ll;", 8920.ToChar() },
                                                                                        { @"&ll;", 8810.ToChar() },
                                                                                        { @"&llarr;", 8647.ToChar() },
                                                                                        {
                                                                                            // { @"&Lfr;", 120079.ToChar() },
                                                                                            @"&llcorner;", 8990.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Lleftarrow;",
                                                                                            8666.ToChar()
                                                                                        },
                                                                                        { @"&llhard;", 10603.ToChar() },
                                                                                        { @"&lltri;", 9722.ToChar() },
                                                                                        { @"&Lmidot;", 319.ToChar() },
                                                                                        { @"&lmidot;", 320.ToChar() },
                                                                                        { @"&lmoust;", 9136.ToChar() },
                                                                                        {
                                                                                            @"&lmoustache;",
                                                                                            9136.ToChar()
                                                                                        },
                                                                                        { @"&lnap;", 10889.ToChar() },
                                                                                        {
                                                                                            @"&lnapprox;",
                                                                                            10889.ToChar()
                                                                                        },
                                                                                        { @"&lnE;", 8808.ToChar() },
                                                                                        { @"&lne;", 10887.ToChar() },
                                                                                        { @"&lneq;", 10887.ToChar() },
                                                                                        { @"&lneqq;", 8808.ToChar() },
                                                                                        { @"&lnsim;", 8934.ToChar() },
                                                                                        { @"&loang;", 10220.ToChar() },
                                                                                        { @"&loarr;", 8701.ToChar() },
                                                                                        { @"&lobrk;", 10214.ToChar() },
                                                                                        {
                                                                                            @"&LongLeftArrow;",
                                                                                            10229.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Longleftarrow;",
                                                                                            10232.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&longleftarrow;",
                                                                                            10229.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LongLeftRightArrow;",
                                                                                            10231.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Longleftrightarrow;",
                                                                                            10234.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&longleftrightarrow;",
                                                                                            10231.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&longmapsto;",
                                                                                            10236.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LongRightArrow;",
                                                                                            10230.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Longrightarrow;",
                                                                                            10233.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&longrightarrow;",
                                                                                            10230.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&looparrowleft;",
                                                                                            8619.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&looparrowright;",
                                                                                            8620.ToChar()
                                                                                        },
                                                                                        { @"&lopar;", 10629.ToChar() },

                                                                                        // { @"&lfr;", 120105.ToChar() },
                                                                                        { @"&loplus;", 10797.ToChar() },
                                                                                        {
                                                                                            // { @"&Lopf;", 120131.ToChar() },
                                                                                            @"&lotimes;", 10804.ToChar()
                                                                                        },
                                                                                        { @"&lowast;", 8727.ToChar() },
                                                                                        { @"&lowbar;", 95.ToChar() },
                                                                                        {
                                                                                            @"&LowerLeftArrow;",
                                                                                            8601.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&LowerRightArrow;",
                                                                                            8600.ToChar()
                                                                                        },
                                                                                        { @"&loz;", 9674.ToChar() },
                                                                                        { @"&lozenge;", 9674.ToChar() },
                                                                                        { @"&lozf;", 10731.ToChar() },
                                                                                        { @"&lpar;", 40.ToChar() },
                                                                                        { @"&lparlt;", 10643.ToChar() },
                                                                                        { @"&lrarr;", 8646.ToChar() },
                                                                                        {
                                                                                            @"&lrcorner;", 8991.ToChar()
                                                                                        },
                                                                                        { @"&lrhar;", 8651.ToChar() },
                                                                                        { @"&lrhard;", 10605.ToChar() },
                                                                                        { @"&lrm;", 8206.ToChar() },
                                                                                        { @"&lrtri;", 8895.ToChar() },
                                                                                        { @"&lsaquo;", 8249.ToChar() },
                                                                                        { @"&Lscr;", 8466.ToChar() },
                                                                                        { @"&Lsh;", 8624.ToChar() },
                                                                                        { @"&lsh;", 8624.ToChar() },
                                                                                        { @"&lsim;", 8818.ToChar() },
                                                                                        { @"&lsime;", 10893.ToChar() },
                                                                                        { @"&lsimg;", 10895.ToChar() },
                                                                                        { @"&lsqb;", 91.ToChar() },
                                                                                        { @"&lsquo;", 8216.ToChar() },
                                                                                        { @"&lsquor;", 8218.ToChar() },
                                                                                        { @"&Lstrok;", 321.ToChar() },
                                                                                        { @"&lstrok;", 322.ToChar() },
                                                                                        { @"&LT;", 60.ToChar() },
                                                                                        { @"&Lt;", 8810.ToChar() },
                                                                                        { @"&lt;", 60.ToChar() },
                                                                                        { @"&ltcc;", 10918.ToChar() },
                                                                                        { @"&ltcir;", 10873.ToChar() },
                                                                                        { @"&ltdot;", 8918.ToChar() },
                                                                                        { @"&lthree;", 8907.ToChar() },
                                                                                        { @"&ltimes;", 8905.ToChar() },
                                                                                        { @"&ltlarr;", 10614.ToChar() },
                                                                                        {
                                                                                            // { @"&lopf;", 120157.ToChar() },
                                                                                            @"&ltquest;", 10875.ToChar()
                                                                                        },
                                                                                        { @"&ltri;", 9667.ToChar() },
                                                                                        { @"&ltrie;", 8884.ToChar() },
                                                                                        { @"&ltrif;", 9666.ToChar() },
                                                                                        { @"&ltrPar;", 10646.ToChar() },
                                                                                        {
                                                                                            @"&lurdshar;",
                                                                                            10570.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&luruhar;", 10598.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&lvertneqq;",
                                                                                            8808.ToChar()
                                                                                        },
                                                                                        { @"&lvnE;", 8808.ToChar() },
                                                                                        { @"&macr;", 175.ToChar() },
                                                                                        { @"&male;", 9794.ToChar() },
                                                                                        { @"&malt;", 10016.ToChar() },
                                                                                        {
                                                                                            @"&maltese;", 10016.ToChar()
                                                                                        },
                                                                                        { @"&Map;", 10501.ToChar() },
                                                                                        { @"&map;", 8614.ToChar() },
                                                                                        { @"&mapsto;", 8614.ToChar() },
                                                                                        {
                                                                                            @"&mapstodown;",
                                                                                            8615.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&mapstoleft;",
                                                                                            8612.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&mapstoup;", 8613.ToChar()
                                                                                        },
                                                                                        { @"&marker;", 9646.ToChar() },
                                                                                        { @"&mcomma;", 10793.ToChar() },
                                                                                        { @"&Mcy;", 1052.ToChar() },
                                                                                        { @"&mcy;", 1084.ToChar() },
                                                                                        { @"&mdash;", 8212.ToChar() },
                                                                                        { @"&mDDot;", 8762.ToChar() },
                                                                                        {
                                                                                            @"&measuredangle;",
                                                                                            8737.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&MediumSpace;",
                                                                                            8287.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Mellintrf;",
                                                                                            8499.ToChar()
                                                                                        },

                                                                                        // { @"&lscr;", 120001.ToChar() },
                                                                                        { @"&mho;", 8487.ToChar() },
                                                                                        { @"&micro;", 181.ToChar() },
                                                                                        { @"&mid;", 8739.ToChar() },
                                                                                        { @"&midast;", 42.ToChar() },
                                                                                        { @"&midcir;", 10992.ToChar() },
                                                                                        { @"&middot;", 183.ToChar() },
                                                                                        { @"&minus;", 8722.ToChar() },
                                                                                        { @"&minusb;", 8863.ToChar() },
                                                                                        { @"&minusd;", 8760.ToChar() },
                                                                                        {
                                                                                            // { @"&Mfr;", 120080.ToChar() },
                                                                                            @"&minusdu;", 10794.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&MinusPlus;",
                                                                                            8723.ToChar()
                                                                                        },
                                                                                        { @"&mlcp;", 10971.ToChar() },
                                                                                        { @"&mldr;", 8230.ToChar() },
                                                                                        { @"&mnplus;", 8723.ToChar() },
                                                                                        { @"&models;", 8871.ToChar() },

                                                                                        // { @"&mfr;", 120106.ToChar() },
                                                                                        { @"&mp;", 8723.ToChar() },
                                                                                        { @"&Mscr;", 8499.ToChar() },

                                                                                        // { @"&Mopf;", 120132.ToChar() },
                                                                                        { @"&mstpos;", 8766.ToChar() },
                                                                                        { @"&Mu;", 924.ToChar() },
                                                                                        { @"&mu;", 956.ToChar() },
                                                                                        {
                                                                                            // { @"&mopf;", 120158.ToChar() },
                                                                                            @"&multimap;", 8888.ToChar()
                                                                                        },
                                                                                        { @"&mumap;", 8888.ToChar() },
                                                                                        { @"&nabla;", 8711.ToChar() },
                                                                                        { @"&Nacute;", 323.ToChar() },
                                                                                        { @"&nacute;", 324.ToChar() },
                                                                                        { @"&nang;", 8736.ToChar() },
                                                                                        { @"&nap;", 8777.ToChar() },
                                                                                        { @"&napE;", 10864.ToChar() },
                                                                                        { @"&napid;", 8779.ToChar() },
                                                                                        { @"&napos;", 329.ToChar() },
                                                                                        { @"&napprox;", 8777.ToChar() },
                                                                                        { @"&natur;", 9838.ToChar() },
                                                                                        { @"&natural;", 9838.ToChar() },
                                                                                        {
                                                                                            @"&naturals;", 8469.ToChar()
                                                                                        },
                                                                                        { @"&nbsp;", 160.ToChar() },
                                                                                        { @"&nbump;", 8782.ToChar() },
                                                                                        { @"&nbumpe;", 8783.ToChar() },
                                                                                        { @"&ncap;", 10819.ToChar() },
                                                                                        { @"&Ncaron;", 327.ToChar() },
                                                                                        { @"&ncaron;", 328.ToChar() },
                                                                                        { @"&Ncedil;", 325.ToChar() },
                                                                                        { @"&ncedil;", 326.ToChar() },
                                                                                        { @"&ncong;", 8775.ToChar() },
                                                                                        {
                                                                                            @"&ncongdot;",
                                                                                            10861.ToChar()
                                                                                        },
                                                                                        { @"&ncup;", 10818.ToChar() },
                                                                                        { @"&Ncy;", 1053.ToChar() },
                                                                                        { @"&ncy;", 1085.ToChar() },
                                                                                        { @"&ndash;", 8211.ToChar() },
                                                                                        { @"&ne;", 8800.ToChar() },
                                                                                        { @"&nearhk;", 10532.ToChar() },
                                                                                        { @"&neArr;", 8663.ToChar() },
                                                                                        { @"&nearr;", 8599.ToChar() },
                                                                                        { @"&nearrow;", 8599.ToChar() },
                                                                                        { @"&nedot;", 8784.ToChar() },
                                                                                        {
                                                                                            @"&NegativeMediumSpace;",
                                                                                            8203.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NegativeThickSpace;",
                                                                                            8203.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NegativeThinSpace;",
                                                                                            8203.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NegativeVeryThinSpace;",
                                                                                            8203.ToChar()
                                                                                        },
                                                                                        { @"&nequiv;", 8802.ToChar() },
                                                                                        { @"&nesear;", 10536.ToChar() },
                                                                                        { @"&nesim;", 8770.ToChar() },
                                                                                        {
                                                                                            @"&NestedGreaterGreater;",
                                                                                            8811.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NestedLessLess;",
                                                                                            8810.ToChar()
                                                                                        },
                                                                                        { @"&NewLine;", 10.ToChar() },
                                                                                        { @"&nexist;", 8708.ToChar() },
                                                                                        { @"&nexists;", 8708.ToChar() },

                                                                                        // { @"&mscr;", 120002.ToChar() },
                                                                                        { @"&ngE;", 8807.ToChar() },
                                                                                        { @"&nge;", 8817.ToChar() },
                                                                                        { @"&ngeq;", 8817.ToChar() },
                                                                                        { @"&ngeqq;", 8807.ToChar() },
                                                                                        {
                                                                                            // { @"&Nfr;", 120081.ToChar() },
                                                                                            @"&ngeqslant;",
                                                                                            10878.ToChar()
                                                                                        },
                                                                                        { @"&nges;", 10878.ToChar() },
                                                                                        { @"&nGg;", 8921.ToChar() },
                                                                                        { @"&ngsim;", 8821.ToChar() },
                                                                                        { @"&nGt;", 8811.ToChar() },
                                                                                        { @"&ngt;", 8815.ToChar() },
                                                                                        { @"&ngtr;", 8815.ToChar() },
                                                                                        { @"&nGtv;", 8811.ToChar() },
                                                                                        { @"&nhArr;", 8654.ToChar() },
                                                                                        { @"&nharr;", 8622.ToChar() },
                                                                                        { @"&nhpar;", 10994.ToChar() },
                                                                                        { @"&ni;", 8715.ToChar() },
                                                                                        { @"&nis;", 8956.ToChar() },
                                                                                        { @"&nisd;", 8954.ToChar() },
                                                                                        { @"&niv;", 8715.ToChar() },
                                                                                        { @"&NJcy;", 1034.ToChar() },
                                                                                        { @"&njcy;", 1114.ToChar() },
                                                                                        { @"&nlArr;", 8653.ToChar() },
                                                                                        { @"&nlarr;", 8602.ToChar() },
                                                                                        { @"&nldr;", 8229.ToChar() },
                                                                                        { @"&nlE;", 8806.ToChar() },
                                                                                        { @"&nle;", 8816.ToChar() },
                                                                                        {
                                                                                            @"&nLeftarrow;",
                                                                                            8653.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nleftarrow;",
                                                                                            8602.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nLeftrightarrow;",
                                                                                            8654.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nleftrightarrow;",
                                                                                            8622.ToChar()
                                                                                        },
                                                                                        { @"&nleq;", 8816.ToChar() },
                                                                                        { @"&nleqq;", 8806.ToChar() },
                                                                                        {
                                                                                            @"&nleqslant;",
                                                                                            10877.ToChar()
                                                                                        },
                                                                                        { @"&nles;", 10877.ToChar() },
                                                                                        { @"&nless;", 8814.ToChar() },
                                                                                        { @"&nLl;", 8920.ToChar() },
                                                                                        { @"&nlsim;", 8820.ToChar() },
                                                                                        { @"&nLt;", 8810.ToChar() },
                                                                                        { @"&nlt;", 8814.ToChar() },
                                                                                        { @"&nltri;", 8938.ToChar() },
                                                                                        { @"&nltrie;", 8940.ToChar() },
                                                                                        { @"&nLtv;", 8810.ToChar() },
                                                                                        { @"&nmid;", 8740.ToChar() },
                                                                                        { @"&NoBreak;", 8288.ToChar() },
                                                                                        {
                                                                                            @"&NonBreakingSpace;",
                                                                                            160.ToChar()
                                                                                        },
                                                                                        { @"&Nopf;", 8469.ToChar() },
                                                                                        { @"&Not;", 10988.ToChar() },
                                                                                        { @"&not;", 172.ToChar() },
                                                                                        {
                                                                                            // { @"&nfr;", 120107.ToChar() },
                                                                                            @"&NotCongruent;",
                                                                                            8802.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotCupCap;",
                                                                                            8813.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotDoubleVerticalBar;",
                                                                                            8742.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotElement;",
                                                                                            8713.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotEqual;", 8800.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotEqualTilde;",
                                                                                            8770.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotExists;",
                                                                                            8708.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreater;",
                                                                                            8815.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterEqual;",
                                                                                            8817.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterFullEqual;",
                                                                                            8807.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterGreater;",
                                                                                            8811.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterLess;",
                                                                                            8825.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterSlantEqual;",
                                                                                            10878.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotGreaterTilde;",
                                                                                            8821.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotHumpDownHump;",
                                                                                            8782.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotHumpEqual;",
                                                                                            8783.ToChar()
                                                                                        },
                                                                                        { @"&notin;", 8713.ToChar() },
                                                                                        {
                                                                                            @"&notindot;", 8949.ToChar()
                                                                                        },
                                                                                        { @"&notinE;", 8953.ToChar() },
                                                                                        { @"&notinva;", 8713.ToChar() },
                                                                                        { @"&notinvb;", 8951.ToChar() },
                                                                                        { @"&notinvc;", 8950.ToChar() },
                                                                                        {
                                                                                            @"&NotLeftTriangle;",
                                                                                            8938.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLeftTriangleBar;",
                                                                                            10703.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLeftTriangleEqual;",
                                                                                            8940.ToChar()
                                                                                        },
                                                                                        { @"&NotLess;", 8814.ToChar() },
                                                                                        {
                                                                                            @"&NotLessEqual;",
                                                                                            8816.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLessGreater;",
                                                                                            8824.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLessLess;",
                                                                                            8810.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLessSlantEqual;",
                                                                                            10877.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotLessTilde;",
                                                                                            8820.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotNestedGreaterGreater;",
                                                                                            10914.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotNestedLessLess;",
                                                                                            10913.ToChar()
                                                                                        },
                                                                                        { @"&notni;", 8716.ToChar() },
                                                                                        { @"&notniva;", 8716.ToChar() },
                                                                                        { @"&notnivb;", 8958.ToChar() },
                                                                                        { @"&notnivc;", 8957.ToChar() },
                                                                                        {
                                                                                            @"&NotPrecedes;",
                                                                                            8832.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotPrecedesEqual;",
                                                                                            10927.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotPrecedesSlantEqual;",
                                                                                            8928.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotReverseElement;",
                                                                                            8716.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotRightTriangle;",
                                                                                            8939.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotRightTriangleBar;",
                                                                                            10704.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotRightTriangleEqual;",
                                                                                            8941.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSquareSubset;",
                                                                                            8847.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSquareSubsetEqual;",
                                                                                            8930.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSquareSuperset;",
                                                                                            8848.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSquareSupersetEqual;",
                                                                                            8931.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSubset;",
                                                                                            8834.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSubsetEqual;",
                                                                                            8840.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSucceeds;",
                                                                                            8833.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSucceedsEqual;",
                                                                                            10928.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSucceedsSlantEqual;",
                                                                                            8929.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSucceedsTilde;",
                                                                                            8831.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSuperset;",
                                                                                            8835.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotSupersetEqual;",
                                                                                            8841.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotTilde;", 8769.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotTildeEqual;",
                                                                                            8772.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotTildeFullEqual;",
                                                                                            8775.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotTildeTilde;",
                                                                                            8777.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&NotVerticalBar;",
                                                                                            8740.ToChar()
                                                                                        },
                                                                                        { @"&npar;", 8742.ToChar() },
                                                                                        {
                                                                                            @"&nparallel;",
                                                                                            8742.ToChar()
                                                                                        },
                                                                                        { @"&nparsl;", 11005.ToChar() },
                                                                                        { @"&npart;", 8706.ToChar() },
                                                                                        {
                                                                                            @"&npolint;", 10772.ToChar()
                                                                                        },
                                                                                        { @"&npr;", 8832.ToChar() },
                                                                                        { @"&nprcue;", 8928.ToChar() },
                                                                                        { @"&npre;", 10927.ToChar() },
                                                                                        { @"&nprec;", 8832.ToChar() },
                                                                                        {
                                                                                            @"&npreceq;", 10927.ToChar()
                                                                                        },
                                                                                        { @"&nrArr;", 8655.ToChar() },
                                                                                        { @"&nrarr;", 8603.ToChar() },
                                                                                        { @"&nrarrc;", 10547.ToChar() },
                                                                                        { @"&nrarrw;", 8605.ToChar() },
                                                                                        {
                                                                                            @"&nRightarrow;",
                                                                                            8655.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nrightarrow;",
                                                                                            8603.ToChar()
                                                                                        },
                                                                                        { @"&nrtri;", 8939.ToChar() },
                                                                                        { @"&nrtrie;", 8941.ToChar() },
                                                                                        { @"&nsc;", 8833.ToChar() },
                                                                                        { @"&nsccue;", 8929.ToChar() },
                                                                                        { @"&nsce;", 10928.ToChar() },

                                                                                        // { @"&nopf;", 120159.ToChar() },
                                                                                        {
                                                                                            // { @"&Nscr;", 119977.ToChar() },
                                                                                            @"&nshortmid;",
                                                                                            8740.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nshortparallel;",
                                                                                            8742.ToChar()
                                                                                        },
                                                                                        { @"&nsim;", 8769.ToChar() },
                                                                                        { @"&nsime;", 8772.ToChar() },
                                                                                        { @"&nsimeq;", 8772.ToChar() },
                                                                                        { @"&nsmid;", 8740.ToChar() },
                                                                                        { @"&nspar;", 8742.ToChar() },
                                                                                        { @"&nsqsube;", 8930.ToChar() },
                                                                                        { @"&nsqsupe;", 8931.ToChar() },
                                                                                        { @"&nsub;", 8836.ToChar() },
                                                                                        { @"&nsubE;", 10949.ToChar() },
                                                                                        { @"&nsube;", 8840.ToChar() },
                                                                                        { @"&nsubset;", 8834.ToChar() },
                                                                                        {
                                                                                            @"&nsubseteq;",
                                                                                            8840.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nsubseteqq;",
                                                                                            10949.ToChar()
                                                                                        },
                                                                                        { @"&nsucc;", 8833.ToChar() },
                                                                                        {
                                                                                            @"&nsucceq;", 10928.ToChar()
                                                                                        },
                                                                                        { @"&nsup;", 8837.ToChar() },
                                                                                        { @"&nsupE;", 10950.ToChar() },
                                                                                        { @"&nsupe;", 8841.ToChar() },
                                                                                        { @"&nsupset;", 8835.ToChar() },
                                                                                        {
                                                                                            @"&nsupseteq;",
                                                                                            8841.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&nsupseteqq;",
                                                                                            10950.ToChar()
                                                                                        },
                                                                                        { @"&ntgl;", 8825.ToChar() },
                                                                                        { @"&Ntilde;", 209.ToChar() },
                                                                                        { @"&ntilde;", 241.ToChar() },
                                                                                        { @"&ntlg;", 8824.ToChar() },
                                                                                        {
                                                                                            @"&ntriangleleft;",
                                                                                            8938.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ntrianglelefteq;",
                                                                                            8940.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ntriangleright;",
                                                                                            8939.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ntrianglerighteq;",
                                                                                            8941.ToChar()
                                                                                        },
                                                                                        { @"&Nu;", 925.ToChar() },
                                                                                        { @"&nu;", 957.ToChar() },
                                                                                        { @"&num;", 35.ToChar() },
                                                                                        { @"&numero;", 8470.ToChar() },
                                                                                        { @"&numsp;", 8199.ToChar() },
                                                                                        { @"&nvap;", 8781.ToChar() },
                                                                                        { @"&nVDash;", 8879.ToChar() },
                                                                                        { @"&nVdash;", 8878.ToChar() },
                                                                                        { @"&nvDash;", 8877.ToChar() },
                                                                                        { @"&nvdash;", 8876.ToChar() },
                                                                                        { @"&nvge;", 8805.ToChar() },
                                                                                        { @"&nvgt;", 62.ToChar() },
                                                                                        { @"&nvHarr;", 10500.ToChar() },
                                                                                        {
                                                                                            @"&nvinfin;", 10718.ToChar()
                                                                                        },
                                                                                        { @"&nvlArr;", 10498.ToChar() },
                                                                                        { @"&nvle;", 8804.ToChar() },
                                                                                        { @"&nvlt;", 60.ToChar() },
                                                                                        { @"&nvltrie;", 8884.ToChar() },
                                                                                        { @"&nvrArr;", 10499.ToChar() },
                                                                                        { @"&nvrtrie;", 8885.ToChar() },
                                                                                        { @"&nvsim;", 8764.ToChar() },
                                                                                        { @"&nwarhk;", 10531.ToChar() },
                                                                                        { @"&nwArr;", 8662.ToChar() },
                                                                                        { @"&nwarr;", 8598.ToChar() },
                                                                                        { @"&nwarrow;", 8598.ToChar() },
                                                                                        { @"&nwnear;", 10535.ToChar() },
                                                                                        { @"&Oacute;", 211.ToChar() },
                                                                                        { @"&oacute;", 243.ToChar() },
                                                                                        { @"&oast;", 8859.ToChar() },
                                                                                        { @"&ocir;", 8858.ToChar() },
                                                                                        { @"&Ocirc;", 212.ToChar() },
                                                                                        { @"&ocirc;", 244.ToChar() },
                                                                                        { @"&Ocy;", 1054.ToChar() },
                                                                                        { @"&ocy;", 1086.ToChar() },
                                                                                        { @"&odash;", 8861.ToChar() },
                                                                                        { @"&Odblac;", 336.ToChar() },
                                                                                        { @"&odblac;", 337.ToChar() },
                                                                                        { @"&odiv;", 10808.ToChar() },
                                                                                        { @"&odot;", 8857.ToChar() },
                                                                                        { @"&odsold;", 10684.ToChar() },
                                                                                        { @"&OElig;", 338.ToChar() },
                                                                                        { @"&oelig;", 339.ToChar() },
                                                                                        { @"&ofcir;", 10687.ToChar() },

                                                                                        // { @"&nscr;", 120003.ToChar() },
                                                                                        { @"&ogon;", 731.ToChar() },
                                                                                        { @"&Ograve;", 210.ToChar() },
                                                                                        { @"&ograve;", 242.ToChar() },
                                                                                        { @"&ogt;", 10689.ToChar() },
                                                                                        { @"&ohbar;", 10677.ToChar() },
                                                                                        { @"&ohm;", 937.ToChar() },
                                                                                        { @"&oint;", 8750.ToChar() },
                                                                                        { @"&olarr;", 8634.ToChar() },
                                                                                        { @"&olcir;", 10686.ToChar() },
                                                                                        {
                                                                                            // { @"&Ofr;", 120082.ToChar() },
                                                                                            @"&olcross;", 10683.ToChar()
                                                                                        },
                                                                                        { @"&oline;", 8254.ToChar() },
                                                                                        { @"&olt;", 10688.ToChar() },
                                                                                        { @"&Omacr;", 332.ToChar() },
                                                                                        { @"&omacr;", 333.ToChar() },
                                                                                        { @"&Omega;", 937.ToChar() },
                                                                                        { @"&omega;", 969.ToChar() },
                                                                                        { @"&Omicron;", 927.ToChar() },
                                                                                        { @"&omicron;", 959.ToChar() },
                                                                                        { @"&omid;", 10678.ToChar() },
                                                                                        { @"&ominus;", 8854.ToChar() },

                                                                                        // { @"&ofr;", 120108.ToChar() },
                                                                                        { @"&opar;", 10679.ToChar() },
                                                                                        {
                                                                                            // { @"&Oopf;", 120134.ToChar() },
                                                                                            @"&OpenCurlyDoubleQuote;",
                                                                                            8220.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&OpenCurlyQuote;",
                                                                                            8216.ToChar()
                                                                                        },
                                                                                        { @"&operp;", 10681.ToChar() },
                                                                                        { @"&oplus;", 8853.ToChar() },
                                                                                        { @"&Or;", 10836.ToChar() },
                                                                                        { @"&or;", 8744.ToChar() },
                                                                                        { @"&orarr;", 8635.ToChar() },
                                                                                        { @"&ord;", 10845.ToChar() },
                                                                                        { @"&order;", 8500.ToChar() },
                                                                                        { @"&orderof;", 8500.ToChar() },
                                                                                        { @"&ordf;", 170.ToChar() },
                                                                                        { @"&ordm;", 186.ToChar() },
                                                                                        { @"&origof;", 8886.ToChar() },
                                                                                        { @"&oror;", 10838.ToChar() },
                                                                                        {
                                                                                            @"&orslope;", 10839.ToChar()
                                                                                        },
                                                                                        { @"&orv;", 10843.ToChar() },
                                                                                        { @"&oS;", 9416.ToChar() },
                                                                                        { @"&oscr;", 8500.ToChar() },
                                                                                        { @"&Oslash;", 216.ToChar() },
                                                                                        { @"&oslash;", 248.ToChar() },
                                                                                        { @"&osol;", 8856.ToChar() },
                                                                                        { @"&Otilde;", 213.ToChar() },
                                                                                        { @"&otilde;", 245.ToChar() },
                                                                                        { @"&Otimes;", 10807.ToChar() },
                                                                                        { @"&otimes;", 8855.ToChar() },
                                                                                        {
                                                                                            // { @"&oopf;", 120160.ToChar() },
                                                                                            @"&otimesas;",
                                                                                            10806.ToChar()
                                                                                        },
                                                                                        { @"&Ouml;", 214.ToChar() },
                                                                                        { @"&ouml;", 246.ToChar() },
                                                                                        { @"&ovbar;", 9021.ToChar() },
                                                                                        { @"&OverBar;", 8254.ToChar() },
                                                                                        {
                                                                                            @"&OverBrace;",
                                                                                            9182.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&OverBracket;",
                                                                                            9140.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&OverParenthesis;",
                                                                                            9180.ToChar()
                                                                                        },
                                                                                        { @"&par;", 8741.ToChar() },
                                                                                        { @"&para;", 182.ToChar() },
                                                                                        {
                                                                                            @"&parallel;", 8741.ToChar()
                                                                                        },
                                                                                        { @"&parsim;", 10995.ToChar() },
                                                                                        { @"&parsl;", 11005.ToChar() },
                                                                                        { @"&part;", 8706.ToChar() },
                                                                                        {
                                                                                            @"&PartialD;", 8706.ToChar()
                                                                                        },
                                                                                        { @"&Pcy;", 1055.ToChar() },
                                                                                        { @"&pcy;", 1087.ToChar() },
                                                                                        { @"&percnt;", 37.ToChar() },
                                                                                        { @"&period;", 46.ToChar() },
                                                                                        { @"&permil;", 8240.ToChar() },
                                                                                        { @"&perp;", 8869.ToChar() },
                                                                                        { @"&pertenk;", 8241.ToChar() },

                                                                                        // { @"&Oscr;", 119978.ToChar() },
                                                                                        { @"&Phi;", 934.ToChar() },
                                                                                        { @"&phi;", 966.ToChar() },
                                                                                        { @"&phiv;", 981.ToChar() },
                                                                                        { @"&phmmat;", 8499.ToChar() },
                                                                                        { @"&phone;", 9742.ToChar() },
                                                                                        { @"&Pi;", 928.ToChar() },
                                                                                        { @"&pi;", 960.ToChar() },
                                                                                        {
                                                                                            // { @"&Pfr;", 120083.ToChar() },
                                                                                            @"&pitchfork;",
                                                                                            8916.ToChar()
                                                                                        },
                                                                                        { @"&piv;", 982.ToChar() },
                                                                                        { @"&planck;", 8463.ToChar() },
                                                                                        { @"&planckh;", 8462.ToChar() },
                                                                                        { @"&plankv;", 8463.ToChar() },
                                                                                        { @"&plus;", 43.ToChar() },
                                                                                        {
                                                                                            @"&plusacir;",
                                                                                            10787.ToChar()
                                                                                        },
                                                                                        { @"&plusb;", 8862.ToChar() },
                                                                                        {
                                                                                            @"&pluscir;", 10786.ToChar()
                                                                                        },
                                                                                        { @"&plusdo;", 8724.ToChar() },
                                                                                        { @"&plusdu;", 10789.ToChar() },
                                                                                        { @"&pluse;", 10866.ToChar() },
                                                                                        {
                                                                                            @"&PlusMinus;", 177.ToChar()
                                                                                        },
                                                                                        { @"&plusmn;", 177.ToChar() },
                                                                                        {
                                                                                            @"&plussim;", 10790.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&plustwo;", 10791.ToChar()
                                                                                        },
                                                                                        { @"&pm;", 177.ToChar() },
                                                                                        {
                                                                                            @"&Poincareplane;",
                                                                                            8460.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&pointint;",
                                                                                            10773.ToChar()
                                                                                        },
                                                                                        { @"&Popf;", 8473.ToChar() },
                                                                                        { @"&pound;", 163.ToChar() },
                                                                                        { @"&Pr;", 10939.ToChar() },
                                                                                        { @"&pr;", 8826.ToChar() },
                                                                                        { @"&prap;", 10935.ToChar() },
                                                                                        { @"&prcue;", 8828.ToChar() },
                                                                                        { @"&prE;", 10931.ToChar() },
                                                                                        { @"&pre;", 10927.ToChar() },
                                                                                        { @"&prec;", 8826.ToChar() },
                                                                                        {
                                                                                            // { @"&pfr;", 120109.ToChar() },
                                                                                            @"&precapprox;",
                                                                                            10935.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&preccurlyeq;",
                                                                                            8828.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Precedes;", 8826.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&PrecedesEqual;",
                                                                                            10927.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&PrecedesSlantEqual;",
                                                                                            8828.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&PrecedesTilde;",
                                                                                            8830.ToChar()
                                                                                        },
                                                                                        { @"&preceq;", 10927.ToChar() },
                                                                                        {
                                                                                            @"&precnapprox;",
                                                                                            10937.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&precneqq;",
                                                                                            10933.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&precnsim;", 8936.ToChar()
                                                                                        },
                                                                                        { @"&precsim;", 8830.ToChar() },
                                                                                        { @"&Prime;", 8243.ToChar() },
                                                                                        { @"&prime;", 8242.ToChar() },
                                                                                        { @"&primes;", 8473.ToChar() },
                                                                                        { @"&prnap;", 10937.ToChar() },
                                                                                        { @"&prnE;", 10933.ToChar() },
                                                                                        { @"&prnsim;", 8936.ToChar() },
                                                                                        { @"&prod;", 8719.ToChar() },
                                                                                        { @"&Product;", 8719.ToChar() },
                                                                                        {
                                                                                            @"&profalar;", 9006.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&profline;", 8978.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&profsurf;", 8979.ToChar()
                                                                                        },
                                                                                        { @"&prop;", 8733.ToChar() },
                                                                                        {
                                                                                            @"&Proportion;",
                                                                                            8759.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Proportional;",
                                                                                            8733.ToChar()
                                                                                        },
                                                                                        { @"&propto;", 8733.ToChar() },
                                                                                        { @"&prsim;", 8830.ToChar() },
                                                                                        { @"&prurel;", 8880.ToChar() },

                                                                                        // { @"&popf;", 120161.ToChar() },
                                                                                        { @"&Psi;", 936.ToChar() },
                                                                                        { @"&psi;", 968.ToChar() },
                                                                                        { @"&puncsp;", 8200.ToChar() },

                                                                                        // { @"&Pscr;", 119979.ToChar() },

                                                                                        // { @"&pscr;", 120005.ToChar() },
                                                                                        { @"&qint;", 10764.ToChar() },
                                                                                        { @"&Qopf;", 8474.ToChar() },

                                                                                        // { @"&Qfr;", 120084.ToChar() },
                                                                                        { @"&qprime;", 8279.ToChar() },

                                                                                        // { @"&qfr;", 120110.ToChar() },

                                                                                        // { @"&qopf;", 120162.ToChar() },
                                                                                        {
                                                                                            // { @"&Qscr;", 119980.ToChar() },
                                                                                            @"&quaternions;",
                                                                                            8461.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&quatint;", 10774.ToChar()
                                                                                        },
                                                                                        { @"&quest;", 63.ToChar() },
                                                                                        { @"&questeq;", 8799.ToChar() },
                                                                                        { @"&QUOT;", 34.ToChar() },
                                                                                        { @"&quot;", 34.ToChar() },
                                                                                        { @"&rAarr;", 8667.ToChar() },
                                                                                        { @"&race;", 8765.ToChar() },
                                                                                        { @"&Racute;", 340.ToChar() },
                                                                                        { @"&racute;", 341.ToChar() },
                                                                                        { @"&radic;", 8730.ToChar() },
                                                                                        {
                                                                                            @"&raemptyv;",
                                                                                            10675.ToChar()
                                                                                        },
                                                                                        { @"&Rang;", 10219.ToChar() },
                                                                                        { @"&rang;", 10217.ToChar() },
                                                                                        { @"&rangd;", 10642.ToChar() },
                                                                                        { @"&range;", 10661.ToChar() },
                                                                                        { @"&rangle;", 10217.ToChar() },
                                                                                        { @"&raquo;", 187.ToChar() },
                                                                                        { @"&Rarr;", 8608.ToChar() },
                                                                                        { @"&rArr;", 8658.ToChar() },
                                                                                        { @"&rarr;", 8594.ToChar() },
                                                                                        { @"&rarrap;", 10613.ToChar() },
                                                                                        { @"&rarrb;", 8677.ToChar() },
                                                                                        {
                                                                                            @"&rarrbfs;", 10528.ToChar()
                                                                                        },
                                                                                        { @"&rarrc;", 10547.ToChar() },
                                                                                        { @"&rarrfs;", 10526.ToChar() },
                                                                                        { @"&rarrhk;", 8618.ToChar() },
                                                                                        { @"&rarrlp;", 8620.ToChar() },
                                                                                        { @"&rarrpl;", 10565.ToChar() },
                                                                                        {
                                                                                            @"&rarrsim;", 10612.ToChar()
                                                                                        },
                                                                                        { @"&Rarrtl;", 10518.ToChar() },
                                                                                        { @"&rarrtl;", 8611.ToChar() },
                                                                                        { @"&rarrw;", 8605.ToChar() },
                                                                                        { @"&rAtail;", 10524.ToChar() },
                                                                                        { @"&ratail;", 10522.ToChar() },
                                                                                        { @"&ratio;", 8758.ToChar() },
                                                                                        {
                                                                                            @"&rationals;",
                                                                                            8474.ToChar()
                                                                                        },
                                                                                        { @"&RBarr;", 10512.ToChar() },
                                                                                        { @"&rBarr;", 10511.ToChar() },
                                                                                        { @"&rbarr;", 10509.ToChar() },
                                                                                        { @"&rbbrk;", 10099.ToChar() },
                                                                                        { @"&rbrace;", 125.ToChar() },
                                                                                        { @"&rbrack;", 93.ToChar() },
                                                                                        { @"&rbrke;", 10636.ToChar() },
                                                                                        {
                                                                                            @"&rbrksld;", 10638.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rbrkslu;", 10640.ToChar()
                                                                                        },
                                                                                        { @"&Rcaron;", 344.ToChar() },
                                                                                        { @"&rcaron;", 345.ToChar() },
                                                                                        { @"&Rcedil;", 342.ToChar() },
                                                                                        { @"&rcedil;", 343.ToChar() },
                                                                                        { @"&rceil;", 8969.ToChar() },
                                                                                        { @"&rcub;", 125.ToChar() },
                                                                                        { @"&Rcy;", 1056.ToChar() },
                                                                                        { @"&rcy;", 1088.ToChar() },
                                                                                        { @"&rdca;", 10551.ToChar() },
                                                                                        {
                                                                                            @"&rdldhar;", 10601.ToChar()
                                                                                        },
                                                                                        { @"&rdquo;", 8221.ToChar() },
                                                                                        { @"&rdquor;", 8221.ToChar() },
                                                                                        { @"&rdsh;", 8627.ToChar() },
                                                                                        { @"&Re;", 8476.ToChar() },
                                                                                        { @"&real;", 8476.ToChar() },
                                                                                        { @"&realine;", 8475.ToChar() },
                                                                                        {
                                                                                            @"&realpart;", 8476.ToChar()
                                                                                        },
                                                                                        { @"&reals;", 8477.ToChar() },
                                                                                        { @"&rect;", 9645.ToChar() },
                                                                                        { @"&REG;", 174.ToChar() },
                                                                                        { @"&reg;", 174.ToChar() },
                                                                                        {
                                                                                            @"&ReverseElement;",
                                                                                            8715.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ReverseEquilibrium;",
                                                                                            8651.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ReverseUpEquilibrium;",
                                                                                            10607.ToChar()
                                                                                        },
                                                                                        { @"&rfisht;", 10621.ToChar() },
                                                                                        { @"&rfloor;", 8971.ToChar() },
                                                                                        { @"&Rfr;", 8476.ToChar() },
                                                                                        { @"&rHar;", 10596.ToChar() },
                                                                                        { @"&rhard;", 8641.ToChar() },
                                                                                        { @"&rharu;", 8640.ToChar() },
                                                                                        { @"&rharul;", 10604.ToChar() },
                                                                                        { @"&Rho;", 929.ToChar() },
                                                                                        { @"&rho;", 961.ToChar() },
                                                                                        { @"&rhov;", 1009.ToChar() },
                                                                                        {
                                                                                            // { @"&qscr;", 120006.ToChar() },
                                                                                            @"&RightAngleBracket;",
                                                                                            10217.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightArrow;",
                                                                                            8594.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Rightarrow;",
                                                                                            8658.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightarrow;",
                                                                                            8594.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightArrowBar;",
                                                                                            8677.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightArrowLeftArrow;",
                                                                                            8644.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightarrowtail;",
                                                                                            8611.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightCeiling;",
                                                                                            8969.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightDoubleBracket;",
                                                                                            10215.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightDownTeeVector;",
                                                                                            10589.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightDownVector;",
                                                                                            8642.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightDownVectorBar;",
                                                                                            10581.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightFloor;",
                                                                                            8971.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightharpoondown;",
                                                                                            8641.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightharpoonup;",
                                                                                            8640.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightleftarrows;",
                                                                                            8644.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightleftharpoons;",
                                                                                            8652.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightrightarrows;",
                                                                                            8649.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightsquigarrow;",
                                                                                            8605.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTee;", 8866.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTeeArrow;",
                                                                                            8614.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTeeVector;",
                                                                                            10587.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&rightthreetimes;",
                                                                                            8908.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTriangle;",
                                                                                            8883.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTriangleBar;",
                                                                                            10704.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightTriangleEqual;",
                                                                                            8885.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightUpDownVector;",
                                                                                            10575.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightUpTeeVector;",
                                                                                            10588.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightUpVector;",
                                                                                            8638.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightUpVectorBar;",
                                                                                            10580.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightVector;",
                                                                                            8640.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RightVectorBar;",
                                                                                            10579.ToChar()
                                                                                        },
                                                                                        { @"&ring;", 730.ToChar() },
                                                                                        {
                                                                                            @"&risingdotseq;",
                                                                                            8787.ToChar()
                                                                                        },
                                                                                        { @"&rlarr;", 8644.ToChar() },
                                                                                        { @"&rlhar;", 8652.ToChar() },
                                                                                        { @"&rlm;", 8207.ToChar() },
                                                                                        { @"&rmoust;", 9137.ToChar() },
                                                                                        {
                                                                                            @"&rmoustache;",
                                                                                            9137.ToChar()
                                                                                        },
                                                                                        { @"&rnmid;", 10990.ToChar() },
                                                                                        { @"&roang;", 10221.ToChar() },
                                                                                        { @"&roarr;", 8702.ToChar() },
                                                                                        { @"&robrk;", 10215.ToChar() },
                                                                                        { @"&ropar;", 10630.ToChar() },
                                                                                        { @"&Ropf;", 8477.ToChar() },
                                                                                        { @"&roplus;", 10798.ToChar() },
                                                                                        {
                                                                                            // { @"&rfr;", 120111.ToChar() },
                                                                                            @"&rotimes;", 10805.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RoundImplies;",
                                                                                            10608.ToChar()
                                                                                        },
                                                                                        { @"&rpar;", 41.ToChar() },
                                                                                        { @"&rpargt;", 10644.ToChar() },
                                                                                        {
                                                                                            @"&rppolint;",
                                                                                            10770.ToChar()
                                                                                        },
                                                                                        { @"&rrarr;", 8649.ToChar() },
                                                                                        {
                                                                                            @"&Rrightarrow;",
                                                                                            8667.ToChar()
                                                                                        },
                                                                                        { @"&rsaquo;", 8250.ToChar() },
                                                                                        { @"&Rscr;", 8475.ToChar() },
                                                                                        { @"&Rsh;", 8625.ToChar() },
                                                                                        { @"&rsh;", 8625.ToChar() },
                                                                                        { @"&rsqb;", 93.ToChar() },
                                                                                        { @"&rsquo;", 8217.ToChar() },
                                                                                        { @"&rsquor;", 8217.ToChar() },
                                                                                        { @"&rthree;", 8908.ToChar() },
                                                                                        { @"&rtimes;", 8906.ToChar() },
                                                                                        { @"&rtri;", 9657.ToChar() },
                                                                                        { @"&rtrie;", 8885.ToChar() },
                                                                                        { @"&rtrif;", 9656.ToChar() },
                                                                                        {
                                                                                            // { @"&ropf;", 120163.ToChar() },
                                                                                            @"&rtriltri;",
                                                                                            10702.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&RuleDelayed;",
                                                                                            10740.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ruluhar;", 10600.ToChar()
                                                                                        },
                                                                                        { @"&rx;", 8478.ToChar() },
                                                                                        { @"&Sacute;", 346.ToChar() },
                                                                                        { @"&sacute;", 347.ToChar() },
                                                                                        { @"&sbquo;", 8218.ToChar() },
                                                                                        { @"&Sc;", 10940.ToChar() },
                                                                                        { @"&sc;", 8827.ToChar() },
                                                                                        { @"&scap;", 10936.ToChar() },
                                                                                        { @"&Scaron;", 352.ToChar() },
                                                                                        { @"&scaron;", 353.ToChar() },
                                                                                        { @"&sccue;", 8829.ToChar() },
                                                                                        { @"&scE;", 10932.ToChar() },
                                                                                        { @"&sce;", 10928.ToChar() },
                                                                                        { @"&Scedil;", 350.ToChar() },
                                                                                        { @"&scedil;", 351.ToChar() },
                                                                                        { @"&Scirc;", 348.ToChar() },
                                                                                        { @"&scirc;", 349.ToChar() },
                                                                                        { @"&scnap;", 10938.ToChar() },
                                                                                        { @"&scnE;", 10934.ToChar() },
                                                                                        { @"&scnsim;", 8937.ToChar() },
                                                                                        {
                                                                                            @"&scpolint;",
                                                                                            10771.ToChar()
                                                                                        },
                                                                                        { @"&scsim;", 8831.ToChar() },
                                                                                        { @"&Scy;", 1057.ToChar() },
                                                                                        { @"&scy;", 1089.ToChar() },
                                                                                        { @"&sdot;", 8901.ToChar() },
                                                                                        { @"&sdotb;", 8865.ToChar() },
                                                                                        { @"&sdote;", 10854.ToChar() },
                                                                                        { @"&searhk;", 10533.ToChar() },
                                                                                        { @"&seArr;", 8664.ToChar() },
                                                                                        { @"&searr;", 8600.ToChar() },
                                                                                        { @"&searrow;", 8600.ToChar() },
                                                                                        { @"&sect;", 167.ToChar() },
                                                                                        { @"&semi;", 59.ToChar() },
                                                                                        { @"&seswar;", 10537.ToChar() },
                                                                                        {
                                                                                            @"&setminus;", 8726.ToChar()
                                                                                        },
                                                                                        { @"&setmn;", 8726.ToChar() },
                                                                                        { @"&sext;", 10038.ToChar() },

                                                                                        // { @"&rscr;", 120007.ToChar() },
                                                                                        { @"&sfrown;", 8994.ToChar() },
                                                                                        { @"&sharp;", 9839.ToChar() },
                                                                                        { @"&SHCHcy;", 1065.ToChar() },
                                                                                        { @"&shchcy;", 1097.ToChar() },
                                                                                        { @"&SHcy;", 1064.ToChar() },
                                                                                        { @"&shcy;", 1096.ToChar() },
                                                                                        {
                                                                                            // { @"&Sfr;", 120086.ToChar() },
                                                                                            @"&ShortDownArrow;",
                                                                                            8595.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ShortLeftArrow;",
                                                                                            8592.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&shortmid;", 8739.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&shortparallel;",
                                                                                            8741.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ShortRightArrow;",
                                                                                            8594.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ShortUpArrow;",
                                                                                            8593.ToChar()
                                                                                        },
                                                                                        { @"&shy;", 173.ToChar() },
                                                                                        { @"&Sigma;", 931.ToChar() },
                                                                                        { @"&sigma;", 963.ToChar() },
                                                                                        { @"&sigmaf;", 962.ToChar() },
                                                                                        { @"&sigmav;", 962.ToChar() },
                                                                                        { @"&sim;", 8764.ToChar() },
                                                                                        { @"&simdot;", 10858.ToChar() },
                                                                                        { @"&sime;", 8771.ToChar() },
                                                                                        { @"&simeq;", 8771.ToChar() },
                                                                                        { @"&simg;", 10910.ToChar() },
                                                                                        { @"&simgE;", 10912.ToChar() },
                                                                                        { @"&siml;", 10909.ToChar() },
                                                                                        { @"&simlE;", 10911.ToChar() },
                                                                                        { @"&simne;", 8774.ToChar() },
                                                                                        {
                                                                                            @"&simplus;", 10788.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&simrarr;", 10610.ToChar()
                                                                                        },
                                                                                        { @"&slarr;", 8592.ToChar() },
                                                                                        {
                                                                                            @"&SmallCircle;",
                                                                                            8728.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&smallsetminus;",
                                                                                            8726.ToChar()
                                                                                        },
                                                                                        { @"&smashp;", 10803.ToChar() },
                                                                                        {
                                                                                            @"&smeparsl;",
                                                                                            10724.ToChar()
                                                                                        },
                                                                                        { @"&smid;", 8739.ToChar() },
                                                                                        { @"&smile;", 8995.ToChar() },
                                                                                        { @"&smt;", 10922.ToChar() },
                                                                                        { @"&smte;", 10924.ToChar() },
                                                                                        { @"&smtes;", 10924.ToChar() },
                                                                                        { @"&SOFTcy;", 1068.ToChar() },
                                                                                        { @"&softcy;", 1100.ToChar() },
                                                                                        { @"&sol;", 47.ToChar() },
                                                                                        { @"&solb;", 10692.ToChar() },
                                                                                        { @"&solbar;", 9023.ToChar() },

                                                                                        // { @"&sfr;", 120112.ToChar() },
                                                                                        { @"&spades;", 9824.ToChar() },
                                                                                        {
                                                                                            // { @"&Sopf;", 120138.ToChar() },
                                                                                            @"&spadesuit;",
                                                                                            9824.ToChar()
                                                                                        },
                                                                                        { @"&spar;", 8741.ToChar() },
                                                                                        { @"&sqcap;", 8851.ToChar() },
                                                                                        { @"&sqcaps;", 8851.ToChar() },
                                                                                        { @"&sqcup;", 8852.ToChar() },
                                                                                        { @"&sqcups;", 8852.ToChar() },
                                                                                        { @"&Sqrt;", 8730.ToChar() },
                                                                                        { @"&sqsub;", 8847.ToChar() },
                                                                                        { @"&sqsube;", 8849.ToChar() },
                                                                                        {
                                                                                            @"&sqsubset;", 8847.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&sqsubseteq;",
                                                                                            8849.ToChar()
                                                                                        },
                                                                                        { @"&sqsup;", 8848.ToChar() },
                                                                                        { @"&sqsupe;", 8850.ToChar() },
                                                                                        {
                                                                                            @"&sqsupset;", 8848.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&sqsupseteq;",
                                                                                            8850.ToChar()
                                                                                        },
                                                                                        { @"&squ;", 9633.ToChar() },
                                                                                        { @"&Square;", 9633.ToChar() },
                                                                                        { @"&square;", 9633.ToChar() },
                                                                                        {
                                                                                            @"&SquareIntersection;",
                                                                                            8851.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SquareSubset;",
                                                                                            8847.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SquareSubsetEqual;",
                                                                                            8849.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SquareSuperset;",
                                                                                            8848.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SquareSupersetEqual;",
                                                                                            8850.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SquareUnion;",
                                                                                            8852.ToChar()
                                                                                        },
                                                                                        { @"&squarf;", 9642.ToChar() },
                                                                                        { @"&squf;", 9642.ToChar() },
                                                                                        { @"&srarr;", 8594.ToChar() },

                                                                                        // { @"&sopf;", 120164.ToChar() },
                                                                                        { @"&ssetmn;", 8726.ToChar() },
                                                                                        { @"&ssmile;", 8995.ToChar() },
                                                                                        { @"&sstarf;", 8902.ToChar() },
                                                                                        { @"&Star;", 8902.ToChar() },
                                                                                        { @"&star;", 9734.ToChar() },
                                                                                        { @"&starf;", 9733.ToChar() },
                                                                                        {
                                                                                            // { @"&Sscr;", 119982.ToChar() },
                                                                                            @"&straightepsilon;",
                                                                                            1013.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&straightphi;",
                                                                                            981.ToChar()
                                                                                        },
                                                                                        { @"&strns;", 175.ToChar() },
                                                                                        { @"&Sub;", 8912.ToChar() },
                                                                                        { @"&sub;", 8834.ToChar() },
                                                                                        { @"&subdot;", 10941.ToChar() },
                                                                                        { @"&subE;", 10949.ToChar() },
                                                                                        { @"&sube;", 8838.ToChar() },
                                                                                        {
                                                                                            @"&subedot;", 10947.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&submult;", 10945.ToChar()
                                                                                        },
                                                                                        { @"&subnE;", 10955.ToChar() },
                                                                                        { @"&subne;", 8842.ToChar() },
                                                                                        {
                                                                                            @"&subplus;", 10943.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&subrarr;", 10617.ToChar()
                                                                                        },
                                                                                        { @"&Subset;", 8912.ToChar() },
                                                                                        { @"&subset;", 8834.ToChar() },
                                                                                        {
                                                                                            @"&subseteq;", 8838.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&subseteqq;",
                                                                                            10949.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SubsetEqual;",
                                                                                            8838.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&subsetneq;",
                                                                                            8842.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&subsetneqq;",
                                                                                            10955.ToChar()
                                                                                        },
                                                                                        { @"&subsim;", 10951.ToChar() },
                                                                                        { @"&subsub;", 10965.ToChar() },
                                                                                        { @"&subsup;", 10963.ToChar() },
                                                                                        { @"&succ;", 8827.ToChar() },
                                                                                        {
                                                                                            @"&succapprox;",
                                                                                            10936.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&succcurlyeq;",
                                                                                            8829.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Succeeds;", 8827.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SucceedsEqual;",
                                                                                            10928.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SucceedsSlantEqual;",
                                                                                            8829.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SucceedsTilde;",
                                                                                            8831.ToChar()
                                                                                        },
                                                                                        { @"&succeq;", 10928.ToChar() },
                                                                                        {
                                                                                            @"&succnapprox;",
                                                                                            10938.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&succneqq;",
                                                                                            10934.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&succnsim;", 8937.ToChar()
                                                                                        },
                                                                                        { @"&succsim;", 8831.ToChar() },
                                                                                        {
                                                                                            @"&SuchThat;", 8715.ToChar()
                                                                                        },
                                                                                        { @"&Sum;", 8721.ToChar() },
                                                                                        { @"&sum;", 8721.ToChar() },
                                                                                        { @"&sung;", 9834.ToChar() },
                                                                                        { @"&Sup;", 8913.ToChar() },
                                                                                        { @"&sup;", 8835.ToChar() },
                                                                                        { @"&sup1;", 185.ToChar() },
                                                                                        { @"&sup2;", 178.ToChar() },
                                                                                        { @"&sup3;", 179.ToChar() },
                                                                                        { @"&supdot;", 10942.ToChar() },
                                                                                        {
                                                                                            @"&supdsub;", 10968.ToChar()
                                                                                        },
                                                                                        { @"&supE;", 10950.ToChar() },
                                                                                        { @"&supe;", 8839.ToChar() },
                                                                                        {
                                                                                            @"&supedot;", 10948.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Superset;", 8835.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&SupersetEqual;",
                                                                                            8839.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&suphsol;", 10185.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&suphsub;", 10967.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&suplarr;", 10619.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&supmult;", 10946.ToChar()
                                                                                        },
                                                                                        { @"&supnE;", 10956.ToChar() },
                                                                                        { @"&supne;", 8843.ToChar() },
                                                                                        {
                                                                                            @"&supplus;", 10944.ToChar()
                                                                                        },
                                                                                        { @"&Supset;", 8913.ToChar() },
                                                                                        { @"&supset;", 8835.ToChar() },
                                                                                        {
                                                                                            @"&supseteq;", 8839.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&supseteqq;",
                                                                                            10950.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&supsetneq;",
                                                                                            8843.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&supsetneqq;",
                                                                                            10956.ToChar()
                                                                                        },
                                                                                        { @"&supsim;", 10952.ToChar() },
                                                                                        { @"&supsub;", 10964.ToChar() },
                                                                                        { @"&supsup;", 10966.ToChar() },
                                                                                        { @"&swarhk;", 10534.ToChar() },
                                                                                        { @"&swArr;", 8665.ToChar() },
                                                                                        { @"&swarr;", 8601.ToChar() },
                                                                                        { @"&swarrow;", 8601.ToChar() },
                                                                                        { @"&swnwar;", 10538.ToChar() },
                                                                                        { @"&szlig;", 223.ToChar() },
                                                                                        { @"&Tab;", 9.ToChar() },
                                                                                        { @"&target;", 8982.ToChar() },
                                                                                        { @"&Tau;", 932.ToChar() },
                                                                                        { @"&tau;", 964.ToChar() },
                                                                                        { @"&tbrk;", 9140.ToChar() },
                                                                                        { @"&Tcaron;", 356.ToChar() },
                                                                                        { @"&tcaron;", 357.ToChar() },
                                                                                        { @"&Tcedil;", 354.ToChar() },
                                                                                        { @"&tcedil;", 355.ToChar() },
                                                                                        { @"&Tcy;", 1058.ToChar() },
                                                                                        { @"&tcy;", 1090.ToChar() },
                                                                                        { @"&tdot;", 8411.ToChar() },
                                                                                        { @"&telrec;", 8981.ToChar() },

                                                                                        // { @"&sscr;", 120008.ToChar() },
                                                                                        { @"&there4;", 8756.ToChar() },
                                                                                        {
                                                                                            // { @"&Tfr;", 120087.ToChar() },
                                                                                            @"&Therefore;",
                                                                                            8756.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&therefore;",
                                                                                            8756.ToChar()
                                                                                        },
                                                                                        { @"&Theta;", 920.ToChar() },
                                                                                        { @"&theta;", 952.ToChar() },
                                                                                        { @"&thetasym;", 977.ToChar() },
                                                                                        { @"&thetav;", 977.ToChar() },
                                                                                        {
                                                                                            @"&thickapprox;",
                                                                                            8776.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&thicksim;", 8764.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&ThickSpace;",
                                                                                            8287.ToChar()
                                                                                        },
                                                                                        { @"&thinsp;", 8201.ToChar() },
                                                                                        {
                                                                                            @"&ThinSpace;",
                                                                                            8201.ToChar()
                                                                                        },
                                                                                        { @"&thkap;", 8776.ToChar() },
                                                                                        { @"&thksim;", 8764.ToChar() },
                                                                                        { @"&THORN;", 222.ToChar() },
                                                                                        { @"&thorn;", 254.ToChar() },
                                                                                        { @"&Tilde;", 8764.ToChar() },
                                                                                        { @"&tilde;", 732.ToChar() },
                                                                                        {
                                                                                            @"&TildeEqual;",
                                                                                            8771.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&TildeFullEqual;",
                                                                                            8773.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&TildeTilde;",
                                                                                            8776.ToChar()
                                                                                        },
                                                                                        { @"&times;", 215.ToChar() },
                                                                                        { @"&timesb;", 8864.ToChar() },
                                                                                        {
                                                                                            @"&timesbar;",
                                                                                            10801.ToChar()
                                                                                        },
                                                                                        { @"&timesd;", 10800.ToChar() },
                                                                                        { @"&tint;", 8749.ToChar() },
                                                                                        { @"&toea;", 10536.ToChar() },
                                                                                        { @"&top;", 8868.ToChar() },
                                                                                        { @"&topbot;", 9014.ToChar() },
                                                                                        { @"&topcir;", 10993.ToChar() },

                                                                                        // { @"&tfr;", 120113.ToChar() },
                                                                                        {
                                                                                            // { @"&Topf;", 120139.ToChar() },
                                                                                            @"&topfork;", 10970.ToChar()
                                                                                        },
                                                                                        { @"&tosa;", 10537.ToChar() },
                                                                                        { @"&tprime;", 8244.ToChar() },
                                                                                        { @"&TRADE;", 8482.ToChar() },
                                                                                        { @"&trade;", 8482.ToChar() },
                                                                                        {
                                                                                            @"&triangle;", 9653.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&triangledown;",
                                                                                            9663.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&triangleleft;",
                                                                                            9667.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&trianglelefteq;",
                                                                                            8884.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&triangleq;",
                                                                                            8796.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&triangleright;",
                                                                                            9657.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&trianglerighteq;",
                                                                                            8885.ToChar()
                                                                                        },
                                                                                        { @"&tridot;", 9708.ToChar() },
                                                                                        { @"&trie;", 8796.ToChar() },
                                                                                        {
                                                                                            @"&triminus;",
                                                                                            10810.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&TripleDot;",
                                                                                            8411.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&triplus;", 10809.ToChar()
                                                                                        },
                                                                                        { @"&trisb;", 10701.ToChar() },
                                                                                        {
                                                                                            @"&tritime;", 10811.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&trpezium;", 9186.ToChar()
                                                                                        },

                                                                                        // { @"&topf;", 120165.ToChar() },
                                                                                        { @"&TScy;", 1062.ToChar() },
                                                                                        { @"&tscy;", 1094.ToChar() },
                                                                                        { @"&TSHcy;", 1035.ToChar() },
                                                                                        { @"&tshcy;", 1115.ToChar() },
                                                                                        { @"&Tstrok;", 358.ToChar() },
                                                                                        { @"&tstrok;", 359.ToChar() },
                                                                                        { @"&twixt;", 8812.ToChar() },
                                                                                        {
                                                                                            // { @"&Tscr;", 119983.ToChar() },
                                                                                            @"&twoheadleftarrow;",
                                                                                            8606.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&twoheadrightarrow;",
                                                                                            8608.ToChar()
                                                                                        },
                                                                                        { @"&Uacute;", 218.ToChar() },
                                                                                        { @"&uacute;", 250.ToChar() },
                                                                                        { @"&Uarr;", 8607.ToChar() },
                                                                                        { @"&uArr;", 8657.ToChar() },
                                                                                        { @"&uarr;", 8593.ToChar() },
                                                                                        {
                                                                                            @"&Uarrocir;",
                                                                                            10569.ToChar()
                                                                                        },
                                                                                        { @"&Ubrcy;", 1038.ToChar() },
                                                                                        { @"&ubrcy;", 1118.ToChar() },
                                                                                        { @"&Ubreve;", 364.ToChar() },
                                                                                        { @"&ubreve;", 365.ToChar() },
                                                                                        { @"&Ucirc;", 219.ToChar() },
                                                                                        { @"&ucirc;", 251.ToChar() },
                                                                                        { @"&Ucy;", 1059.ToChar() },
                                                                                        { @"&ucy;", 1091.ToChar() },
                                                                                        { @"&udarr;", 8645.ToChar() },
                                                                                        { @"&Udblac;", 368.ToChar() },
                                                                                        { @"&udblac;", 369.ToChar() },
                                                                                        { @"&udhar;", 10606.ToChar() },
                                                                                        { @"&ufisht;", 10622.ToChar() },

                                                                                        // { @"&tscr;", 120009.ToChar() },
                                                                                        { @"&Ugrave;", 217.ToChar() },
                                                                                        { @"&ugrave;", 249.ToChar() },
                                                                                        { @"&uHar;", 10595.ToChar() },
                                                                                        { @"&uharl;", 8639.ToChar() },
                                                                                        { @"&uharr;", 8638.ToChar() },
                                                                                        { @"&uhblk;", 9600.ToChar() },
                                                                                        { @"&ulcorn;", 8988.ToChar() },
                                                                                        {
                                                                                            // { @"&Ufr;", 120088.ToChar() },
                                                                                            @"&ulcorner;", 8988.ToChar()
                                                                                        },
                                                                                        { @"&ulcrop;", 8975.ToChar() },
                                                                                        { @"&ultri;", 9720.ToChar() },
                                                                                        { @"&Umacr;", 362.ToChar() },
                                                                                        { @"&umacr;", 363.ToChar() },
                                                                                        { @"&uml;", 168.ToChar() },
                                                                                        { @"&UnderBar;", 95.ToChar() },
                                                                                        {
                                                                                            @"&UnderBrace;",
                                                                                            9183.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UnderBracket;",
                                                                                            9141.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UnderParenthesis;",
                                                                                            9181.ToChar()
                                                                                        },
                                                                                        { @"&Union;", 8899.ToChar() },
                                                                                        {
                                                                                            @"&UnionPlus;",
                                                                                            8846.ToChar()
                                                                                        },
                                                                                        { @"&Uogon;", 370.ToChar() },
                                                                                        { @"&uogon;", 371.ToChar() },

                                                                                        // { @"&ufr;", 120114.ToChar() },
                                                                                        { @"&UpArrow;", 8593.ToChar() },
                                                                                        { @"&Uparrow;", 8657.ToChar() },
                                                                                        { @"&uparrow;", 8593.ToChar() },
                                                                                        {
                                                                                            // { @"&Uopf;", 120140.ToChar() },
                                                                                            @"&UpArrowBar;",
                                                                                            10514.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UpArrowDownArrow;",
                                                                                            8645.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UpDownArrow;",
                                                                                            8597.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&Updownarrow;",
                                                                                            8661.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&updownarrow;",
                                                                                            8597.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UpEquilibrium;",
                                                                                            10606.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&upharpoonleft;",
                                                                                            8639.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&upharpoonright;",
                                                                                            8638.ToChar()
                                                                                        },
                                                                                        { @"&uplus;", 8846.ToChar() },
                                                                                        {
                                                                                            @"&UpperLeftArrow;",
                                                                                            8598.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&UpperRightArrow;",
                                                                                            8599.ToChar()
                                                                                        },
                                                                                        { @"&Upsi;", 978.ToChar() },
                                                                                        { @"&upsi;", 965.ToChar() },
                                                                                        { @"&upsih;", 978.ToChar() },
                                                                                        { @"&Upsilon;", 933.ToChar() },
                                                                                        { @"&upsilon;", 965.ToChar() },
                                                                                        { @"&UpTee;", 8869.ToChar() },
                                                                                        {
                                                                                            @"&UpTeeArrow;",
                                                                                            8613.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&upuparrows;",
                                                                                            8648.ToChar()
                                                                                        },
                                                                                        { @"&urcorn;", 8989.ToChar() },
                                                                                        {
                                                                                            @"&urcorner;", 8989.ToChar()
                                                                                        },
                                                                                        { @"&urcrop;", 8974.ToChar() },
                                                                                        { @"&Uring;", 366.ToChar() },
                                                                                        { @"&uring;", 367.ToChar() },
                                                                                        { @"&urtri;", 9721.ToChar() },

                                                                                        // { @"&uopf;", 120166.ToChar() },
                                                                                        { @"&utdot;", 8944.ToChar() },
                                                                                        { @"&Utilde;", 360.ToChar() },
                                                                                        { @"&utilde;", 361.ToChar() },
                                                                                        { @"&utri;", 9653.ToChar() },
                                                                                        { @"&utrif;", 9652.ToChar() },
                                                                                        { @"&uuarr;", 8648.ToChar() },
                                                                                        { @"&Uuml;", 220.ToChar() },
                                                                                        { @"&uuml;", 252.ToChar() },
                                                                                        {
                                                                                            // { @"&Uscr;", 119984.ToChar() },
                                                                                            @"&uwangle;", 10663.ToChar()
                                                                                        },
                                                                                        { @"&vangrt;", 10652.ToChar() },
                                                                                        {
                                                                                            @"&varepsilon;",
                                                                                            1013.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&varkappa;", 1008.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&varnothing;",
                                                                                            8709.ToChar()
                                                                                        },
                                                                                        { @"&varphi;", 981.ToChar() },
                                                                                        { @"&varpi;", 982.ToChar() },
                                                                                        {
                                                                                            @"&varpropto;",
                                                                                            8733.ToChar()
                                                                                        },
                                                                                        { @"&vArr;", 8661.ToChar() },
                                                                                        { @"&varr;", 8597.ToChar() },
                                                                                        { @"&varrho;", 1009.ToChar() },
                                                                                        { @"&varsigma;", 962.ToChar() },
                                                                                        {
                                                                                            @"&varsubsetneq;",
                                                                                            8842.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&varsubsetneqq;",
                                                                                            10955.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&varsupsetneq;",
                                                                                            8843.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&varsupsetneqq;",
                                                                                            10956.ToChar()
                                                                                        },
                                                                                        { @"&vartheta;", 977.ToChar() },
                                                                                        {
                                                                                            @"&vartriangleleft;",
                                                                                            8882.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&vartriangleright;",
                                                                                            8883.ToChar()
                                                                                        },
                                                                                        { @"&Vbar;", 10987.ToChar() },
                                                                                        { @"&vBar;", 10984.ToChar() },
                                                                                        { @"&vBarv;", 10985.ToChar() },
                                                                                        { @"&Vcy;", 1042.ToChar() },
                                                                                        { @"&vcy;", 1074.ToChar() },
                                                                                        { @"&VDash;", 8875.ToChar() },
                                                                                        { @"&Vdash;", 8873.ToChar() },
                                                                                        { @"&vDash;", 8872.ToChar() },
                                                                                        { @"&vdash;", 8866.ToChar() },
                                                                                        { @"&Vdashl;", 10982.ToChar() },
                                                                                        { @"&Vee;", 8897.ToChar() },
                                                                                        { @"&vee;", 8744.ToChar() },
                                                                                        { @"&veebar;", 8891.ToChar() },
                                                                                        { @"&veeeq;", 8794.ToChar() },
                                                                                        { @"&vellip;", 8942.ToChar() },
                                                                                        { @"&Verbar;", 8214.ToChar() },
                                                                                        { @"&verbar;", 124.ToChar() },
                                                                                        { @"&Vert;", 8214.ToChar() },
                                                                                        { @"&vert;", 124.ToChar() },
                                                                                        {
                                                                                            @"&VerticalBar;",
                                                                                            8739.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&VerticalLine;",
                                                                                            124.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&VerticalSeparator;",
                                                                                            10072.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&VerticalTilde;",
                                                                                            8768.ToChar()
                                                                                        },
                                                                                        {
                                                                                            @"&VeryThinSpace;",
                                                                                            8202.ToChar()
                                                                                        },

                                                                                        // { @"&uscr;", 120010.ToChar() },
                                                                                        { @"&vltri;", 8882.ToChar() },
                                                                                        { @"&vnsub;", 8834.ToChar() },
                                                                                        { @"&vnsup;", 8835.ToChar() },

                                                                                        // { @"&Vfr;", 120089.ToChar() },

                                                                                        // { @"&vfr;", 120115.ToChar() },
                                                                                        { @"&vprop;", 8733.ToChar() },
                                                                                        { @"&vrtri;", 8883.ToChar() },

                                                                                        // { @"&Vopf;", 120141.ToChar() },

                                                                                        // { @"&vopf;", 120167.ToChar() },
                                                                                        { @"&vsubnE;", 10955.ToChar() },
                                                                                        { @"&vsubne;", 8842.ToChar() },
                                                                                        { @"&vsupnE;", 10956.ToChar() },
                                                                                        { @"&vsupne;", 8843.ToChar() },
                                                                                        { @"&Vvdash;", 8874.ToChar() },
                                                                                        {
                                                                                            // { @"&Vscr;", 119985.ToChar() },
                                                                                            @"&vzigzag;", 10650.ToChar()
                                                                                        },
                                                                                        { @"&Wcirc;", 372.ToChar() },
                                                                                        { @"&wcirc;", 373.ToChar() },
                                                                                        { @"&wedbar;", 10847.ToChar() },
                                                                                        { @"&Wedge;", 8896.ToChar() },
                                                                                        { @"&wedge;", 8743.ToChar() },
                                                                                        { @"&wedgeq;", 8793.ToChar() },
                                                                                        { @"&weierp;", 8472.ToChar() },

                                                                                        // { @"&vscr;", 120011.ToChar() },
                                                                                        // { @"&Wfr;", 120090.ToChar() },
                                                                                        // { @"&wfr;", 120116.ToChar() },
                                                                                        { @"&wp;", 8472.ToChar() },
                                                                                        { @"&wr;", 8768.ToChar() },
                                                                                        { @"&wreath;", 8768.ToChar() },

                                                                                        // { @"&Wopf;", 120142.ToChar() },

                                                                                        // { @"&wopf;", 120168.ToChar() },
                                                                                        { @"&xcap;", 8898.ToChar() },
                                                                                        { @"&xcirc;", 9711.ToChar() },
                                                                                        { @"&xcup;", 8899.ToChar() },
                                                                                        { @"&xdtri;", 9661.ToChar() },

                                                                                        // { @"&Wscr;", 119986.ToChar() },

                                                                                        // { @"&wscr;", 120012.ToChar() },
                                                                                        { @"&xhArr;", 10234.ToChar() },
                                                                                        { @"&xharr;", 10231.ToChar() },
                                                                                        { @"&Xi;", 926.ToChar() },
                                                                                        { @"&xi;", 958.ToChar() },
                                                                                        { @"&xlArr;", 10232.ToChar() },
                                                                                        { @"&xlarr;", 10229.ToChar() },
                                                                                        { @"&xmap;", 10236.ToChar() },
                                                                                        { @"&xnis;", 8955.ToChar() },
                                                                                        { @"&xodot;", 10752.ToChar() },

                                                                                        // { @"&Xfr;", 120091.ToChar() },

                                                                                        // { @"&xfr;", 120117.ToChar() },
                                                                                        { @"&xoplus;", 10753.ToChar() },
                                                                                        { @"&xotime;", 10754.ToChar() },
                                                                                        { @"&xrArr;", 10233.ToChar() },
                                                                                        { @"&xrarr;", 10230.ToChar() },

                                                                                        // { @"&Xopf;", 120143.ToChar() },

                                                                                        // { @"&xopf;", 120169.ToChar() },
                                                                                        { @"&xsqcup;", 10758.ToChar() },
                                                                                        { @"&xuplus;", 10756.ToChar() },
                                                                                        { @"&xutri;", 9651.ToChar() },
                                                                                        { @"&xvee;", 8897.ToChar() },
                                                                                        { @"&xwedge;", 8896.ToChar() },
                                                                                        { @"&Yacute;", 221.ToChar() },
                                                                                        { @"&yacute;", 253.ToChar() },
                                                                                        { @"&YAcy;", 1071.ToChar() },
                                                                                        { @"&yacy;", 1103.ToChar() },
                                                                                        { @"&Ycirc;", 374.ToChar() },
                                                                                        { @"&ycirc;", 375.ToChar() },
                                                                                        { @"&Ycy;", 1067.ToChar() },
                                                                                        { @"&ycy;", 1099.ToChar() },
                                                                                        { @"&yen;", 165.ToChar() },

                                                                                        // { @"&Xscr;", 119987.ToChar() },

                                                                                        // { @"&xscr;", 120013.ToChar() },
                                                                                        { @"&YIcy;", 1031.ToChar() },
                                                                                        { @"&yicy;", 1111.ToChar() },

                                                                                        // { @"&Yfr;", 120092.ToChar() },

                                                                                        // { @"&yfr;", 120118.ToChar() },
                                                                                        // { @"&Yopf;", 120144.ToChar() },
                                                                                        // { @"&yopf;", 120170.ToChar() },
                                                                                        { @"&YUcy;", 1070.ToChar() },
                                                                                        { @"&yucy;", 1102.ToChar() },
                                                                                        { @"&Yuml;", 376.ToChar() },
                                                                                        { @"&yuml;", 255.ToChar() },
                                                                                        { @"&Zacute;", 377.ToChar() },
                                                                                        { @"&zacute;", 378.ToChar() },
                                                                                        { @"&Zcaron;", 381.ToChar() },
                                                                                        { @"&zcaron;", 382.ToChar() },
                                                                                        { @"&Zcy;", 1047.ToChar() },
                                                                                        { @"&zcy;", 1079.ToChar() },
                                                                                        { @"&Zdot;", 379.ToChar() },
                                                                                        { @"&zdot;", 380.ToChar() },
                                                                                        { @"&zeetrf;", 8488.ToChar() },
                                                                                        {
                                                                                            // { @"&Yscr;", 119988.ToChar() },
                                                                                            @"&ZeroWidthSpace;",
                                                                                            8203.ToChar()
                                                                                        },
                                                                                        { @"&Zeta;", 918.ToChar() },
                                                                                        { @"&zeta;", 950.ToChar() },
                                                                                        { @"&Zfr;", 8488.ToChar() },
                                                                                        { @"&ZHcy;", 1046.ToChar() },
                                                                                        { @"&zhcy;", 1078.ToChar() },
                                                                                        { @"&zigrarr;", 8669.ToChar() },
                                                                                        { @"&Zopf;", 8484.ToChar() },

                                                                                        // { @"&yscr;", 120014.ToChar() },

                                                                                        // { @"&zfr;", 120119.ToChar() },
                                                                                        // { @"&zopf;", 120171.ToChar() },
                                                                                        { @"&zwj;", 8205.ToChar() },
                                                                                        { @"&zwnj;", 8204.ToChar() },

                                                                                        // { @"&Zscr;", 119989.ToChar() },

                                                                                        // { @"&zscr;", 120015.ToChar() },
                                                                                    };
    }
}